• Du befindest Dich hier:
• Community
• »
• Mitglieder
• »
• Kileak
• »
• Beiträge von Kileak

Vielleicht versteh ich dich ja einfach nur falsch, aber:

private ?

Von einer 32Bit-Anwendung auf den 64Bit-Teil zuzugreifen ist in meinen Augen zwar nicht die feine englische Art, aber wenn Du es unbedingt brauchst kannst Du es auch über die WinApi-Version RegOpenKeyEx machen...

pinvoke.net: regopenkeyex (advapi32)

Da steht alles was Du brauchst (weiter unten ist sogar direkt ein Beispiel für deinen Frage)

Schon, der Presenter sollte den Aufruf einfach ans Model durchreichen.

Die Methode AddOrder kommt ins Model und der Presenter, wie auch der Command rufen die Methode des Models auf (Der Presenter kann auf das Hinzufügen eines Orders im Model ggf. durch ein entsprechendes Event reagieren).

Mit einer rekursiven Methode.

Hast Du überhaupt "Break, when an exception is Thrown" aktiviert?

-> Debug -> Exceptions

Bei "Common Language Runtime Exceptions" einen Haken bei "Thrown" setzen und nochmal probieren.

Da du Selected.Columns ja schon hast, geh ich mal davon aus das du das Selektieren der Spalte ja doch schon hast, und jetzt nur noch an die zugehörigen Zellen-Inhalte kommen willst.

Bin mir grad nicht sicher, ob es nicht eine einfachere Möglichkeit gibt, direkt an die ausgewählten Zellen zu kommen, aber zur Not kommst Du auch nur über den ColumnHeader an die Inhalte, in dem Du über die Rows iterierst und direkt auf die Zelle zugreifst.

(Ungetestet, da grad kein Infragistics zur Hand)

foreach (ColumnHeader colHeader in gridX.Selected.Columns) {
  foreach(UltraGridRow row in gridX.Rows) {
    value = row[colHeader.Column]
  }
}

Setz AutoClose auf true, und fang stattdessen das Closing-Event ab

private void contextMenuStrip1_Closing(object sender, ToolStripDropDownClosingEventArgs e)
{
    if (e.CloseReason == ToolStripDropDownCloseReason.ItemClicked)
        e.Cancel = true;
}

Das kommt mir zu einfach vor

    public delegate T MethodDel<T, T1>(T1 paramArgs);

    public class MethodList<T, T1>
    {
        private static Dictionary<string, MethodDel<T, T1>> Methods { get; set; }

        public MethodList()
        {
            Methods = new Dictionary<string, MethodDel<T, T1>>();
        }

        public void Register(string methodKey, MethodDel<T, T1> method)
        {
            if (!Methods.ContainsKey(methodKey))
                Methods.Add(methodKey, method);
        }

        public MethodDel<T, T1> this[string methodKey]
        {
            get
            {
                if (Methods.ContainsKey(methodKey))
                    return Methods[methodKey];

                return ((T1 b) => { Trace.WriteLine(string.Format("Method not implemented ({0})", methodKey)); return default(T); });
            }
        }
    }

    public static class MethodFactory<T, T1>
    {
        public static MethodList<T, T1> Methods { get; private set; }

        static MethodFactory()
        {
            Methods = new MethodList<T, T1>();
        }

        public static void Register(string methodKey, MethodDel<T, T1> method)
        {
            Methods.Register(methodKey, method);
        }
    }

public int Method1(int param)
{
    Console.WriteLine("Method1");

    return 0;
}

public int Method2(int param)
{
    Console.WriteLine("Method2");

    return 0;
}

...

MethodFactory<int,int>.Register("a", Method1);
MethodFactory<int,int>.Register("b", Method2);
MethodFactory<int,int>.Register("c", testClass.Method3);

string eingabe = Console.ReadLine();
int param = 10;

MethodFactory<int, int>.Methods[eingabe](param);

Ich nehme dafür meist eine generische EventArgs-Klasse, mit der man auf die Schnelle beliebige Argumente übergeben kann

public class EventArgs<T> : EventArgs
{
    public T Data { get; set; }

    public EventArgs(T data)
    {
        Data = data;
    }
}

public event EventHandler<EventArgs<string>> TestEvent

...
if (TestEvent != null)
{
    TestEvent(this, new EventArgs<string>("Test"));
}

void Form1_TestEvent(object sender, EventArgs<string> e)
{
    MessageBox.Show(e.Data);
}

Über den sender des Events kommst du an das entspr. ToolStripItem das den Dateinamen enthält (bei deinem Beispielt kämst Du so z.B. über das Text-Property an den Dateinamen)

    ToolStripItem item =  fileToolStripMenuItem.DropDownItems.Add("Dateiname");
    item.Click += new EventHandler(item_Click);
}

void item_Click(object sender, EventArgs e)
{
    ToolStripItem srcItem = sender as ToolStripItem;

    if (srcItem != null)
    {
        MessageBox.Show(srcItem.Text);
    }
}

Ohne FusionLog zu kennen, ist dein Versuch den EnableLog-Schlüssel anzulegen wohl etwas schiefgegangen.

Lösch den Eintrag, danach Rechtsklick auf Fusion->"Neu"->"DWORD-Wert". Nenn den Eintrag EnableLog und setz den Wert auf 1.

Dasselbe mit dem LogResourceBinds-Eintrag.

Kurz: Überschreibe die ToString-Methode in der mitarbeiter-Klasse...

Fürs Verschieben zwischen den Trees kannst Du mit DoDragDrop eine Drag&Drop-Operation anfangen und über die DragOver-, DragDrop-Events der Trees feststellen, wenn Items reingezogen wurden.

Meinst Du mit 'schön aussehen' die Oberfläche oder den Code dazu?

Um alle Controls einfach zu deaktivieren/aktivieren einfach ein Panel auf die Form und die entspr. Controls reingezogen, und im Code lediglich das Panel enablen/disablen.

Wenns dir um das Aussehen der Oberfläche geht: Der Benutzer ist sicher froh darüber, am 'Disabled'-Aussehen der Buttons, Textboxen, etc. direkt zu wissen, dass er diese nicht ändern kann.

Solang M233 lokal deklariert bleibt, wird sie beim M233.Kill() auch nie definiert sein...

Eine andere Möglichkeit wäre auch eine Wrapper-Methode in der Basisklasse, die statt deiner abstrakten Methode aufgerufen wird. Diese ruft entspr. die implementierte Methode auf und feuert danach das Event.

So muss dein 'Implementierer' nichts von dem Event wissen und nur die entspr. abstrakte Methode überschreiben.

Grad so hingekritzelt sähe das so aus

public class BaseClassXYZ {
  protected abstract xyzMethode();

  public void Methode() {
    xyzMethode();
    FireEvent();
  }
}

Da Du die writeLog-Methode für jedes Item extra aufrufst, hat dein Begin/EndUpdate so ziemlich gar keinen Effekt, da Du letztenendes ja doch immer nur ein Item hinzufügst. Der Effekt ist also derselbe als wenn Du es ganz weglassen würdest.

Eine kleine Verbesserung wäre vielleicht zumindest eine Liste, in der dein Thread die Items hinzufügen kann, und Du aus dieser Liste dann alle x Items deine ListView aktualisierst (bzw. sobald dein Thread fertig ist, alle restlichen Items).

Benutz immer dasselbe Tooltip-Objekt und erstelle nicht für jeden Hover ein neues

ToolTip testTool = new ToolTip();

private void listView1_ItemMouseHover(object sender, ListViewItemMouseHoverEventArgs e)
{
    testTool.Hide(listView1);
    testTool.Show(e.Item.Text, listView1, 3000);
}

Ohne jetzt deinen ganzen Ansatz komplett nachvollzogen zu haben, scheinen mir da doch einige Ungereimtheiten drin zu sein.

Zum einen benutzt du eine lokale Variable l sowie l als Index für die for-schleife. Abgesehen davon das sich der Code so nicht kompilieren lässt, ist so auch nicht ganz nachzuvollziehen welches l wann genutzt werden soll.

Soll die Matrix über das gesamte 2-dimensionale Array laufen, sind wohl auch zwei verschachtelte for-schleifen angebracht, im Moment durchläufst Du ja nur einmal die Breite deines Arrays (wobei Du dann auch noch in jedem Schritt nur einen Wert deiner Matrix hinzurechnest).

Falls ich dich nicht ganz missverstanden habe, möchtest Du z.B. eine 3x3 Matrix von oben links über alle Spalten/Zeilen wandern lassen und jeweils den Mittelwert der 9 Werte berechnen.

Das könnte dann so in diese Richtung aussehen.

// zweidimensionales Array durchlaufen
for (int y=0; y<hoehe-matrixHoehe; ++y) {
  for (int x=0; x<breite-matrixBreite; ++x) {
    // Die Matrix an sich durchlaufen
    for (int ym=0; ym<matrixHoehe; ++ym) {
      for (int xm=0; xm<matrixBreite; ++xm) {
          // Wert aus dem Array
          zweiDim[x+xm, y+ym]
       }
      }
    }
  }
}

Über Screen kannst Du dir auch die genauen Positionen des zweiten Bildschirms holen (und bist so unabhängig davon ob er "links" oder "rechts" vom primären ist)

So könntest Du z.B. eine Form auf dem sekundären über den gesamten Bildschirm anzeigen lassen

if (Screen.AllScreens != null && Screen.AllScreens.Length > 1)
{               
    FormBorderStyle = FormBorderStyle.None;

    Location = new Point(Screen.AllScreens[1].Bounds.X, Screen.AllScreens[1].Bounds.Y);
    Size = new Size(Screen.AllScreens[1].Bounds.Width, Screen.AllScreens[1].Bounds.Height);                
}

GetFiles liefert dir ein Array zurück, das Du als einzelnes Objekt deiner Fileliste hinzufügst, daher ist deren Grösse 1.

Wenn Du dir dieses eine Element ansiehst, wirst Du merken das es wiederum ein Array mit den gesuchten Dateinamen ist (string[]).

Du könntest es also entweder als

string[] fileList = Directory.GetFiles(@"C:\", "*.txt");

FileListe.AddRange (Directory.GetFiles(@"C:\", "*.txt"));

Was spricht dagegen das Menü einfach bei

Control.MousePosition

RowIndex ist, wie der Name vermuten lässt, der Index der Zeile, nicht der Spalte ;)

An die Spaltenüberschrift kommst Du z.B. mit

dataGridView.Columns[e.ColumnIndex].HeaderText

Dann hast Du wohl deinem Control vorm Hinzufügen zu deinem Fenster keinen korrekten Namen gegeben, über den Du es später in der Control-Collection finden kannst.

Label testControl = new Label();
testControl.Text = "Woohoo";
testControl.Name = "testName";

Controls.Add(testControl);

Control[] controls = Controls.Find("testName", true);

if (controls != null && controls.Length > 0)
{
    controls[0].Text = "Test yay";
}
else
{
    MessageBox.Show("Control not found");
}

Wenn jeder Name "wirklich" nur einmal vorkommen dürfte (was grade bei Namen wie Müller&Co doch sehr fraglich ist), könntest Du dafür einen Hashtable nehmen.

Da würde sich dann auch wie von dir gewünscht mit

HashtableName["Maier"]

MSDN: Math.Round(double)

Nicht ausprobiert, aber mit einer BindingSource dazwischen sollte das funktionieren.

bindingSource.DataSource = listWarenkorb;
lbWarenkorb.DataSource = bindingSource;

bindingSource.ResetBindings(false);