Hi ich schreib gerade eine eigene Class und wie kann ich das machen das, wenn ich einen Punkt mach die vorschläge bekomm??
Wie bei den bild ??

Hallo,

Das bei deinem Beispiel ist keine Klasse, das ist ein Enum. Siehe hier: http://msdn.microsoft.com/de-de/library/sbbt4032%28VS.80%29.aspx

Jan

Hi Jan,

Danke für deine schnelle Hilfe.

PS: Wie kann ich das enum von eine andern namespace aus benutzen??
Im gleich funzt es schon.

Hat sich erledingt hatte public vergessen

MFG Oliver G

Was muss man machen das, das enum als bezeichner anerkannt wird oder wie kann man das esnum so verwenden?
Denn das hab ich bei den Link nicht gefunden. Ich hoff ichb hab es nicht übersehn

public string CallMessageBox(string FensterTitel, string FensterText, string FensterStyle, enum NewMessageBoxStyle)
{

}

       

Hallo Oliver,

nehmen wir als Beispiel das AnchorStyles Enum. Für die Verwendung kannst Du ÜBERALL folgende Codezeile verwenden (Voraussetzung ist eine Referenz von System.Windows.Forms.dll):

System.Windows.Forms.AnchorStyles myEnumVariable = System.Windows.Forms.AnchorStyles.Left;

Wenn Du eine Enumeration per Parameter in einer Methode übergeben willst, dann musst Du die Methode so deklarieren:

public void MyCustomMethod(System.Windows.Forms.AnchorStyles myEnumParameter)
{
   // do what ever you want
}

Nur wenn Du eigene Enumerationen definieren willst, dann musst Du das Schlüsselwort "enum" verwenden:

public enum AllowedPersons
{
   Oliver,
   Timo
}

Die Verwendung ist dann analog zu dem AnchorStyle.

Grüße
Timo

Ok so wie ich das jetzt Verstehen kann ich entweder enum oder string als verweiss machen ??

Wie kann man dann beides übergeben??

Wie bei:

MessageBox.Show("Text", "Titel", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Error);

Da ist doch auch " String", "String" enum, enum

So schaut es bei mir aus:

namespace NewMessageBox
{
    public enum NewMessageBoxStyle { Fixed3D = 0, FixedDialog, FixedSingle, FixedToolWindow, None, Sizable, SizableToolWindow };
    public enum NewMessageBoxIcon { Asterisk = 1, Error, Exclamation, Information, None, Question, Stop, Warning };
    class NewMessageBox
    {
        public Form MessageBoxFenster;
        public Button Button1;
//------------------------------------------------------------------------------------\\
        public string MessageBoxFensterTitel = null;
        public string MessageBoxFensterText = null;
        public int BoxIcon = 0;
        public int BoxStyle = 0;

        private void MessageBoxFensterSetting()
        {
            // Nicht veränderbare Settings
            MessageBoxFenster = new Form();
            MessageBoxFenster.StartPosition = FormStartPosition.CenterScreen;
//---------------------------------------------------
            // [ Fenster Titel ] 
            MessageBoxFenster.Text = MessageBoxFensterTitel;
            // Fenster Text
            //
            // Code...
            //
            // [ MessageBox Style ]
            if (BoxStyle == 0) MessageBoxFenster.FormBorderStyle = FormBorderStyle.Fixed3D;
            if (BoxStyle == 1) MessageBoxFenster.FormBorderStyle = FormBorderStyle.FixedDialog;
            if (BoxStyle == 2) MessageBoxFenster.FormBorderStyle = FormBorderStyle.FixedSingle;
            if (BoxStyle == 3) MessageBoxFenster.FormBorderStyle = FormBorderStyle.FixedToolWindow;
            if (BoxStyle == 4) MessageBoxFenster.FormBorderStyle = FormBorderStyle.None;
            if (BoxStyle == 5) MessageBoxFenster.FormBorderStyle = FormBorderStyle.Sizable;
            if (BoxStyle == 6) MessageBoxFenster.FormBorderStyle = FormBorderStyle.SizableToolWindow;

            // [ MessageBox Icon ]
            //
            // Code...
            //
            MessageBoxFenster.Show();
        }
//------------------------------------------------------------------------------------\\
        public string CallMessageBox(string FensterTitel, string FensterText, string FensterStyle)
        {
            //BoxIcon = (int)NewMessageBoxIcon.None;
            //BoxStyle = (int)NewMessageBoxStyle.None;
            // Fenster Titel 
            if (FensterTitel != null) MessageBoxFensterTitel = FensterTitel;
            // Fenster Text
            if (FensterText != null) MessageBoxFensterText = FensterText;
            // Fenster Style
            if (FensterStyle != null)
            {
            }
            MessageBoxFensterSetting();
            return (null);
        }
    }
}

in der zeile muss ich das enum mit rein bekommen

public string CallMessageBox(string FensterTitel, string FensterText, string FensterStyle)

Hallo Oliver,

na so wie ich es oben beschrieben habe: Zunächst die Methode anders definieren:

public string CallMessageBox(string FensterTitel, string FensterText, NewMessageBoxStyle FensterStyle)

Und der Aufruf dann so:

CallMessageBox("Title", "Message", NewMessageBox.NewMessageBoxStyle.Sizeable);

Grüße
Timo

Danke Timo,

Oh Man und war so  dicht davor, mein Hirn stand sich mal woeder selbst im weg.

PS: Welche Button Kombination  würde ihr gerne haben bei der MessageBox ??


MFG Oliver G

Hallo Oliver,

also gut: Nächster Exkurs in Sachen Enums.

Für Aufzählungen gibt es die Möglichkeit auch das Attribut Flags zu verwenden. Das ermöglicht Dir alle Buttons als solche aufzählen zu lassen und in einer BELIEBIGEN Kombination aszuwerten.

Beispiel:

[FlagsAttribute]
public enum MyButtonEnumeration
{
   OK,
   Abort,
   Ignore // Das ist mein persönlicher Lieblingsknopf ;-)
}

Ein Anwendungsbeispiel wäre dann (ich will OK und Ignore haben):

MyButtonEnumeration buttons = MyButtonEnumeration.OK | MyButtonEnumeration.Ignore;

Wie Du das dann in der Methode auswertest, wenn Du das dann als Parameter reinbekommst, das stelle ich Dir jetzt mal als Hausaufgabe ;-)

Grüße
Timo

Ich muss sagen ich hab ganz schöne Problem mit der Class denn die Controls müssen ja die Position veränder ja nach dem wievie Text drin ist das funzt so weit, nur wenn ich im Text (String) Escape-Sequenzen  drin ist funzt des net so wie ich will.
Ich hab schon nach gesehn aber ich hab es nicht gefundne wie des bei der MessageBox gehandhabt wird.

Den der Text steuert ja die Grösse der MessageBox.

Also so mach des ich, ja ich weiss des ist kein schöner code:

int TextLange = GetMessage.Length;
            if (TextLange <= 1500)
            {
                StringBuilder GetMessageString = new StringBuilder(GetMessage);
                if (TextLange >= 100) GetMessageString.Insert(100, "\n");
                if (TextLange >= 200) GetMessageString.Insert(201, "\n");
                if (TextLange >= 300) GetMessageString.Insert(302, "\n");
                if (TextLange >= 400) GetMessageString.Insert(403, "\n");
                if (TextLange >= 500) GetMessageString.Insert(504, "\n");
                if (TextLange >= 600)
                {
                    GetMessageString.Insert(605, "\n");
                    InfoBoxFenster.Height = 240;
                }
                if (TextLange >= 700)
                {
                    GetMessageString.Insert(706, "\n");
                    InfoBoxFenster.Height = 250;
                }
                if (TextLange >= 800) 
                {
                    GetMessageString.Insert(807, "\n");
                    InfoBoxFenster.Height = 260;
                }
                if (TextLange >= 900)
                {
                    GetMessageString.Insert(908, "\n");
                    InfoBoxFenster.Height = 270;
                }
                if (TextLange >= 1000) 
                {
                    GetMessageString.Insert(1009, "\n");
                    InfoBoxFenster.Height = 280;
                }
                if (TextLange >= 1100) 
                {
                    GetMessageString.Insert(1110, "\n");
                    InfoBoxFenster.Height = 290;
                }
                if (TextLange >= 1200)
                {
                    GetMessageString.Insert(1211, "\n");
                    InfoBoxFenster.Height = 300;
                }
                if (TextLange >= 1300)
                {
                    GetMessageString.Insert(1312, "\n");
                    InfoBoxFenster.Height = 310;
                }
                if (TextLange >= 1400)
                {
                    GetMessageString.Insert(1413, "\n");
                    InfoBoxFenster.Height = 320;
                }
                if (TextLange >= 1500)
                {
                    InfoBoxFenster.Height = 330;
                }
                string TextOUT = GetMessageString.ToString();
                GetMessageString.Remove(0, GetMessageString.Length);
                InfoBoxText.Text = TextOUT;
                InfoCheckBox.Location = new Point(20, InfoBoxFenster.Height - 80);
            }

Der MessageBox Text ist ein Label.

Hallo Oliver,
wir haben es uns zur Aufgabe gemacht, uns gegenseitig bei den Problemen der Software-Entwicklung zu helfen. Das bedeutet aber nicht, dass wir essentielle Grundlagen vermitteln. Diese fehlen dir offenbar noch. Schon in einem anderen Thread habe ich dir empfohlen, dich mit dem Thema OOP zu beschäftigen. So wie es aussieht, hast du in dieser Richtung noch nichts unternommen!
Du fängst ständig irgendwelche neuen Projekte an, obwohl dir das Wissensfundament fehlt. Lerne doch bitte erst einmal die Grundlagen von C# und OOP. Dafür musst du dir keine teuren Bücher kaufen. Im Internet gibt es das alles gratis!

Galileo open books (hab ich dir auch schon einmal genannt).
Die MSDN-Library wartet mit guten Erklärungen und vielen Beispielen auf.
Oder hier, MSDN-Solve.
Dann ist da z.B. noch das MSDN Developer Center.
Und schließlich kannst du über Google oder Bing Unmengen an Blogartikeln finden. Dort haben sich professionelle Entwickler hingesetzt und in tagelanger Arbeit Artikel für Leute wie dich geschrieben. Nutze das Angebot!

Wenn du trotz dieser Menge an Informationen immer noch auf dem Schlauch stehst, kannst du gerne deine Fragen hier stellen.
Software-Entwickler zu sein, bedeutet den ganzen Tag den Kopf rauchen zu lassen und jede Menge Überstunden zu machen. Trotzdem opfern viele noch ihre Freizeit, um hier Hilfe zu leisten. Denke bitte beim nächsten mal daran.

Noch ein Tip bezgl Lernen: Fange nicht einfach Projekte an. Lerne erst einmal die Grundlagen an Hand von kleinen Samples. Wenn du dann verstanden hast wie etwas funktioniert, kannst du dich an ein Projekt wagen. Bevor du aber anfängst in die Tasten zu hauen, mach dir Gedanken über den Lösungsweg und benutze auch ruhig Papier und Bleistift dafür. In dieser Phase müsste dir dein Gefühl schon sagen ob du für diese Aufgabe bereit bist.
Aber auch Profis können sich nicht davon freisprechen dass sie ein ganzes Projekt von vorne bis hinten ohne Probleme auf die Beine stellen können. Dafür schreiben wir sogenannte Spikes. Das sind Miniprogramme, vollkommen losgelöst vom eigentlichen Projekt. In diesen Spikes versuchen wir Lösungswege und gewinnen Erkenntnis.

In diesem Sinne,
Happy learning!

Hi Rainer,

Ja ok da hast du recht,  Sorry.
Die info seiten hab ich in meien datenbank / Lesezeichen.

Das was ich da Gepostet hab ist so einen " Spikes ", wie man die Fenstergrösse mit den Text steuert. (So wie mei der MessageBox).

MFG Oliver G

Das schaut natürlich besser aus und der code ist sauberer. 

string GetMessage = "0000000000000000000000000000000000000000000" +
                               "0000000000000000000000000000000000000000000" +
                               "0000000000000000000000000000000000000000000" +
                               "0000000000000000000000000000000000000000000" +
                               "000000000000000000000000000";
            int Count = 0;
            int Umbruch = 50;
            int MessageLange = GetMessage.Length;
            int MessageUmbruch = MessageLange / Umbruch;
            StringBuilder GetMessageString = new StringBuilder(GetMessage);
            for (int i = 0; i < MessageUmbruch; i++)
            {
                Count = Count + Umbruch;
                if (MessageLange >= Count) GetMessageString.Insert(Count, "\n");
            }
            FensterText.Text = GetMessageString.ToString();

PS: Das mit den Nullen ist nur zum Testen nicht gleich schrein ich hab das mit den " + " gemacht dammit es nicht zu weit nach rechts geht.

MFG Oliver G

Na also, das ist doch schon viel besser!

Aber mal ne Frage: Warum machst du das über eine Messagebox und nicht über ein neues Forms-Fenster?
Vorteile: Du kannst deine eigenen Buttons setzen und wenn du eine readonly multiline Textbox einsetzt, mußt du dir um die Fenstergröße keine Gedanken mehr machen.

Das mach ich doch, es ist eine Form die zu Laufzeit erstellt wird.
Ich mach eine eigne Class mit MessageBox, InputBox, InfoBox dammit ich die " Box " verändern kann ( Back Color, Text Color, FormBorderStyle, usw.. ) ich will die Neue Class aber so ansprechen wie die alte MessageBox nur mit mehr Paramete.

Das mit multiline geht ja ich gib den String " \n " für die neue zeile  und nach 100 Zeichen soll aber auch eine neue Zeile kommen dammit das Fenster nicht so Breit wird. Es soll sich so verhalten wie sie Orginal  MessageBox.

MFG Oliver G