schau dir mal das Ereignis
AppDomain.CurrentDomain.AssemblyResolve
an

so könntest du wenn eine DLL anefordert wird die noch von woanders herladen und dort zurück geben.

sowas ähnliches muss ich bei uns auch machen da wir eine dritt componente haben die in einer älteren und einer neueren Version laufen muss und der dateiname selbst sich zwischen den Versionen nicht geändert hat.

abonnier die Ereignisse ThreadException und UnhandledException.
Eventuell bekomsmte da den richtigen fehler raus.

kurz beispiel

        static void Main(string[] args)
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            Application.ThreadException += new ThreadExceptionEventHandler(Program.Application_ThreadException);
            AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(Program.CurrentDomain_UnhandledException);

        ...
        }

        private static void Application_ThreadException(object sender, ThreadExceptionEventArgs e)
        {
            MeineMsgBox.Show(e.Exception, "Ein unbehandelter Fehler ist aufgetreten!", MessageBoxButtons.OK, MessageBoxIcon.Hand, MessageBoxDefaultButton.Button1);
        }

        private static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
        {
            if (e.ExceptionObject is Exception)
            {
                MeineMsgBox.Show(e.ExceptionObject as Exception, "Ein unbehandelter Fehler ist aufgetreten!", MessageBoxButtons.OK, MessageBoxIcon.Hand, MessageBoxDefaultButton.Button1);
            }
        }

P.S.: MeineMsgBox ist eine eigene MessageBox (nicht vom Framework)

dll als strongname erstellen bringt auch schonmal eine kleine sicherheit

Ich vermute mal du hast die AssemblyVersion erhöht.
Erhöhe nur dei Dateiversion dann sollte ein austausch/aktualisierung problemlos möglich sein.

Über das Paint Ereignis des Controls welches das Spielfeld darstellen soll (z.B. PictureBox, Panel etc) selber zeichnen.

Über das PaintEventArgs des Paint Ereignis kommst du auf das Graphics objekt mit diesem eifnach mittels FillRectangle oder DrawRetangle die einzelnen Felder zeichnen.

Da du feste größen hast ist das zeichnen eigentlich auch ziemlich einfach (das ermitteln der X, Y Koordinaten eines Feldes).
Horizontal FeldNr * 16
Vertikale FeldNr * 16

Use the DrawString Methode with parameter for rectangle and StringFormat.
With StringFormat you can set the alignment.

https://msdn.microsoft.com/de-de/library/21kdfbzs%28v=vs.110%29.aspx
https://msdn.microsoft.com/de-de/library/system.drawing.stringformat.alignment%28v=vs.110%29.aspx

Zum auslesen einer CSV aus dem .Net Framework die Klasse TextFieldParser.

Assembly: Microsoft.VisualBasic
Namespace: Microsoft.VisualBasic.FileIO

zum zeichnen einer Tabelle in der Console zum Beispiel mittels SetCursorPosition
https://msdn.microsoft.com/de-de/library/system.console.cursorleft%28v=vs.110%29.aspx?cs-save-lang=1&cs-lang=csharp#code-snippet-2

Logischer Schluss.
artikel braucht als Key shape
kracht aber nicht mehr wenn punkt und komma ausgetauscht wird.

Im gezeigten Code schiens erstmal die einzige logische stelle zu sein bei der es krachen könnte.

Die einzige unbekannte war der Typ von artikel, ob dieser einfach null liefert (bei unbekannten Keys) (was er wohl macht) oder ArgumentException/IndexOutOfRangeException etc. schmeißt

Könnte hier das Problem sein:

shapes_not_checked.Rows.Add(shape,artikel[shape].ToString());

und zwar das
_artikel[shape] _
null liefert, gerade da du dort die Einträge als Punkt drin hast und mit Komma entsprechend nixs gefunden wurde ???

(Würd mich nur grad so interessiern obs das is)

Ich verwende für CSV eigentlich immer aus dem .Net Framework den TextFieldParser.

Assembly: Microsoft.VisualBasic
Namespace: Microsoft.VisualBasic.FileIO

Vielleicht klappts mit dem.

Deine Log Klasse hat nur Felder.
PropertyGrid geht auf Eigenschaften.

Nachtrag:
Wenn man standard verhalten des PropertyGrid nutzen will ohne mit TypeConverter etc. das händisch nach zu bilden.

Erstmal vorweg, eine Fibu programmiert man nicht einfach so ich würde raten bestehende Software von entsprechende Anbieter zu nehmen.
Wenn ich dran denke was es für unterschiedliche Steuerschlüssel gibt und je nach Ist- oder Solversteuerung wird die Steuer entsprechend anders berechnet.

Darüber hinaus müsste ja auch noch irgendwie die E-Bilanz übertragen werden, das heißt man bräuchte auch noch ein Abschlussprogramm (was eigentlich wie Fibu läuft aber doch andere ansätze hat).
Und die E-Bilanz Umsetzung, ist auch kein Pappenspiel, mal davon abgesehen das die Finanzverwaltung gerne mal an den Keys rumspielt, und es gibt so kleinigkeiten wie ev. Kapitalkontenentwicklung (jetzt für Wirtschaftsjahre 2015 neu, mit entsprechender Rechtsform).

Oder aber du müsstest entsprechend die Datensätze für deinen Steuerberater bereitstellen das er das dann in seine Software die Erfassungen übernehmen kann (oder entsprechend bereitstellen für ev selbst gekaufte "weiterführende" Software)

Da es hier um deine Firma geht, überleg dir besser ob du das wagen willst.

Ich persönlich verwende für normalen Druck C1PrintDocument von ComponentOne.
Für einen RTF/Word ähnlich Bericht wird alles dann eher mit TXTextControl gerendert.
(Beides kostenpflichtig)

(Öfters mal auch beides kombiniert)

Laufen eventuell noch andere externe debugger, verifier oder so?

Per NativeWindow an die WndProc der TextBox hängen.

bissel abgespeckte Version meines NativeWindow

        internal sealed class NativeTextPaint : NativeWindow, IDisposable
        {
            internal NativeTextPaint(TextBox textBox)
            {
                this.textBox = textBox;

                this.AssignHandle(textBox.Handle);
            }

            protected override void WndProc(ref Message m)
            {
                if (isDisposed)
                    base.WndProc(ref m);
                else
                {
                    switch (m.Msg)
                    {
                        case 15: // this is the WM_PAINT message
                            //textBox.Invalidate();
                            // call the default win32 Paint method for the TextBox first
                            base.WndProc(ref m);
                            // draw extra stuff over the TextBox
                            this.Paint();
                            break;
                        default:
                            base.WndProc(ref m);
                            break;
                    }
                }
            }

            private void Paint()
            {
                using (Graphics textBoxGraphics = Graphics.FromHwnd(textBox.Handle))
                {
                   // --- hier zeichnen ---
                }
            }


            public void Dispose()
            {
                if (!isDisposed)
                {
                    ReleaseHandle();

                    textBox = null;

                    GC.SuppressFinalize(this);

                    isDisposed = true;
                }
            }

            private TextBox textBox;
            private bool isDisposed;
        }

Meistens wird ja der ValueType in einer extra Methode entsprechend angepasst
und da reicht ja die einfache ref Angabe im Parameter

Vielleicht liefert dir die Eigenschaft Lines auch schon das was du genau benötigst:
https://msdn.microsoft.com/de-de/library/system.windows.forms.textboxbase.lines%28v=vs.110%29.aspx

Du darst die DataSource der BindingSource nicht auf null setzen, dadurch gehen bindungen verloren.
Zum zurücksetzen dann am besten

bindingSource.DataSource = typeof(meineKlasse);

Wenn du in Visual Studio den Windows Forms Designer aufrufst.
Hast du ja die Toolbox von der du aus Controls auf den Designer ziehen kannst.

Wenn ich in dieser Toolbox nun einen neuen Tab Anlegen
und dort dann meine DLLs auswähle (Choose Items).
Sollte ich ja jetzt in der Toolbox meine eigenen geschrieben Controls zur Verfügung haben.

Diese tauchen aber dort nicht auf, erst über "Show All" (im ContextMenü der Toolbox).
Dort sieht man dann das meine Controls inaktiv sind (werden so leicht gräulich dargestellt).

Und ich erkenne nicht was andere anders machen das deren Controls normal in der Toolbox zur Verfügung stehen.

Und diese DLLs wurden alle noch mit VS 2010 erstellt,
einige schon mit VS 2013 neu compiliert, aber selbst da sind die Controls noch inaktiv.

Irgendwie überseh ich da gerade irgendwas.

Und wie gesagt bei Kollegen bei dennen VS 2010 und VS 2013 auf dem Rechner installiert ist besteht das problem nicht.
Nur anscheinend wenn man nur noch VS 2013 installiert hat.

Vielleicht hat ja jetzt jemand ne Idee.

Das komische ist Drittanbieter Controls haben anscheinend nicht so diese Probleme,
ich konnte jetzt aber im Reflector nicht erkennen was die anders machen.

Zur Zeit lege ich die Controls händig in der Designer.cs an.

Hi,

ich hab bei mir 2010 deinstalliert und 2013 installiert.

Wenn ich jetzt in 2013 in die Toolbox DLL's in den designer reinziehe, die ich damals mit 2010 erstellt habe, werden diese Controls in der Toolbox deaktiviert (sind nicht auswählbar, sieht man auch erst über "Show All").

Es komt auch eine Meldung beim hinzufügen der DLL in die Toolbox:

make sure the controls to add are compatible with the current designer and .net framework version

Hab ich die Projekte der entsprechenden DLL's direkt in der Solution mit drinne, kann ich die dortigen Controls auch normal aus der Toolbox in den designer ziehen.

Ich kann die Controls auch normal händisch per Code anlegen, und läuft auch alles.

Nur in der Toolbox selber sind diese aus irgendeinem Grund deaktiviert,
wenn ich dort die DLL über über den lokalen Pfad anhefte.

Ein andere Kollege hat das gleiche Problem und er hat bei sich auch 2010 deinstalliert.
Bei Kollegen bei dennen VS 2010 und VS 2013 parallel läuft scheint dieses Problem nicht aufzutreten.

Weiß irgendwer wie ich es schaffen kann das meine 2010 DLL's in 2013 laufen ohne direkt die Projekte der Solution hinzufügen zu müssen?

Alle Projekte und DLL's (auch die 2013er) sind in .Net 2.0 kompiliert.
Es handelt sich um Windows Forms DLL's/Projekte.

Such mal nach npgsql, das verwenden wir auch für postgre Zugriff.

Im Link von Coffeebean die Antwort mit CueBanner ist das was du suchst.
(EM_SETCUEBANNER)

in deinem Beispielcode befindest du dich immer noch im MainThread
(ich seh da erstmal keine Background Thread)
du solltest wenn möglich die Exception in FormApl abfangen

ansosnten ev. noch folgende Events abonnieren für Exceptions die dir durch die lappen gehen:

Application.ThreadException += new System.Threading.ThreadExceptionEventHandler(Application_ThreadException);
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);

Springt der Debugger den in das Click Ereignis wenn du dort einen Breakpoint setzt?
Hat dein Formular Steuerelemente?
Denn dann werten diese das Click Ereignis aus und dein Formular bekommt erstmal nixs mit davon.

private void Form1_MouseClick(object sender, MouseEventArgs f, System.Windows.Forms.PaintEventArgs e)

Ist keine standard methode von .Net die für Ereignisse aufrufe hergenommen wird/werden kann.

Du musst dir den Mausbereich im MouseCklick merken.
Invalidate aufrufen, damit das Formular weiß das es sich neu zeichnen soll.
Und im Paint Ereignis mit den germerkten Bereichen zeichnen.

Instanziiere nur einmal dice1 (dein Random Objekt) (z.B. als privates Feld in deiner Form) und nimm immer dieses Objekt zum liefern der Zufallszahl her.

Ist glaube ich ein bekanntes problem von Random, wenn es zu oft hintereinander neu angefordert wird das dann immer der gleiche Wert geliefert wird.

Wie meinst du das mit beim Click ausführen?
Ich hab mal ein propertyGrid mittels C1FlexGrid selbst gebastelt, und dafür folgende Klassen angelegt:

Basisklasse für TypceConverter und UITypeEditor Handling

   /// <summary>
    /// Basisklasse für <see cref="PropertiesControlTypeConverter"/> und <see cref="PropertiesControlUITypeEditor"/>
    /// </summary>
    internal class PropertiesControlTypeDescriptorContext : ITypeDescriptorContext, IServiceProvider, IDisposable
    {
        protected PropertiesControlTypeDescriptorContext(object instance)
        {
            this.instance = instance;

            this.propertyDescriptors = new Dictionary<string, PropertyDescriptor>();
            foreach (PropertyDescriptor pd in TypeDescriptor.GetProperties(instance))
                propertyDescriptors.Add(pd.Name, pd);
        }

        /// <summary>
        /// wechselt akt. zu bearbeitende Eigenschaft
        /// </summary>
        /// <param name="propertyName">name der Eigenschaft die jetzt bearbeitet werden soll</param>
        internal void SetCurrentProperty(string propertyName)
        {
            propertyDescriptors.TryGetValue(propertyName, out propertyDescriptor);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                propertyDescriptors.Clear();

                propertyDescriptor = null;

                GC.SuppressFinalize(this);
            }
        }

        #region IDisposable Members

        /// <summary>
        /// Ressourcen freigeben
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
        }

        #endregion

        #region Statische Methoden

        /// <summary>
        /// liefert <see cref="PropertyDescriptor"/> für angegebene Eigenschaft
        /// </summary>
        /// <param name="instance">Instance aus der Eigenschaft kommt</param>
        /// <param name="propertyName">name der Eigenschaft für das <see cref="PropertyDescriptor"/> geliefert werden soll</param>
        /// <returns><see cref="PropertyDescriptor"/> wenn gefunden, sonst null</returns>
        protected static PropertyDescriptor GetPropertyDescriptor(object instance, string propertyName)
        {
            PropertyDescriptorCollection pdc = TypeDescriptor.GetProperties(instance);
            foreach (PropertyDescriptor pd in pdc)
            {
                if (string.Equals(propertyName, pd.Name, StringComparison.OrdinalIgnoreCase))
                    return pd;
            }
            return null;
        }

        #endregion

        #region ITypeDescriptorContext Members

        /// <summary>
        /// Gets the container representing this System.ComponentModel.TypeDescriptor  { get; }
        /// </summary>
        public IContainer Container
        {
            get { return null; }
        }

        /// <summary>
        /// Gets the object that is connected with this type descriptor request  { get; }
        /// </summary>
        public object Instance
        {
            get { return instance; }
        }

        /// <summary>
        /// Not Implemented
        /// </summary>
        public void OnComponentChanged()
        {
            throw new NotImplementedException("The method or operation is not implemented.");
        }

        /// <summary>
        /// Not Implemented
        /// </summary>
        /// <returns></returns>
        public bool OnComponentChanging()
        {
            throw new NotImplementedException("The method or operation is not implemented.");
        }

        /// <summary>
        /// Gets the System.ComponentModel.PropertyDescriptor that is associated with the given context item.  { get; }
        /// </summary>
        public PropertyDescriptor PropertyDescriptor
        {
            get { return propertyDescriptor; }
        }

        #endregion

        #region IServiceProvider Members

        /// <summary>
        /// Gets the service object of the specified type.
        /// </summary>
        /// <param name="serviceType">An object that specifies the type of service object to get.</param>
        /// <returns>A service object of type serviceType.-or- null if there is no service object of type serviceType.</returns>
        public virtual object GetService(Type serviceType)
        {
            if (serviceType == this.GetType())
                return this;

            return null;
        }

        #endregion

        private readonly object instance;
        private readonly Dictionary<string, PropertyDescriptor> propertyDescriptors;

        private PropertyDescriptor propertyDescriptor;
    }

Für UITypeEditor dann:

    internal class PropertiesControlUITypeEditor : PropertiesControlTypeDescriptorContext
    {
        public PropertiesControlUITypeEditor(Control parent, object instance)
            : base(instance)
        {
            this.uiTypeEditors = new Dictionary<string, UITypeEditor>();

            this.parent = parent;
        }

        /// <summary>
        /// liefert akt. <see cref="UITypeEditor"/>
        /// </summary>
        /// <returns></returns>
        private UITypeEditor GetEditor()
        {
            UITypeEditor uite;
            if (!uiTypeEditors.TryGetValue(PropertyDescriptor.Name, out uite))
            {
                uite = GetEditor(Instance, PropertyDescriptor);
                uiTypeEditors.Add(PropertyDescriptor.Name, uite);
            }

            return uite;
        }

        /// <summary>
        /// prüft ob akt. Eigenschaft (Eigenschaft wird gesetzt über <see cref="PropertiesControlTypeDescriptorContext.SetCurrentProperty"/>) <see cref="UITypeEditor"/> gesetzt hat oder dessen Type
        /// </summary>
        /// <param name="instance">Instance aus der Eigenschaft stammt</param>
        /// <param name="propertyName">name der zu prüfenden Eigenschaft</param>
        /// <returns>true - <see cref="UITypeEditor"/> ist gesetzt</returns>
        public bool HasEditor()
        {
            return (GetEditor() != null);
        }

        /// <summary>
        /// ruft Editor auf und liefert Wert für akt. Eigenschaft (Eigenschaft wird gesetzt über <see cref="PropertiesControlTypeDescriptorContext.SetCurrentProperty"/>)
        /// </summary>
        /// <returns>neue Eigenschaftenwert</returns>
        public object EditValue()
        {
            return GetEditor().EditValue(this, this, PropertyDescriptor.GetValue(Instance));
        }

        public override object GetService(Type serviceType)
        {
            object o = base.GetService(serviceType);
            if (o == null)
            {
                if (serviceType == typeof(System.Windows.Forms.Design.IWindowsFormsEditorService))
                {
                    if (windowsFormsEditorService == null)
                        windowsFormsEditorService = new WindowsFormsEditorService(parent);
                    return windowsFormsEditorService;
                }
            }
            return null;
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (windowsFormsEditorService != null)
                {
                    windowsFormsEditorService.Dispose();
                    windowsFormsEditorService = null;
                }

                uiTypeEditors.Clear();
            }

            base.Dispose(disposing);
        }

        #region Statische Methoden

        /// <summary>
        /// liefert <see cref="UITypeEditor"/> wenn gesetzt oder der Type der Eigenschaft dies gesetzt hat sonst null
        /// </summary>
        private static UITypeEditor GetEditor(object instance, PropertyDescriptor propertyDescriptor)
        {
            //EditorAttribute ea = null;
            //foreach (Attribute attr in propertyDescriptor.Attributes)
            //{
            //    if (attr is EditorAttribute)
            //    {
            //        ea = (EditorAttribute)attr;
            //        break;
            //    }
            //}

            //if (ea == null)
            //{
            //    object[] attrs = propertyDescriptor.PropertyType.GetCustomAttributes(typeof(EditorAttribute), true);
            //    if (attrs.GetLength(0) > 0)
            //        ea = (EditorAttribute)attrs[0];
            //}

            //if (ea != null)
            //    return (UITypeEditor)Activator.CreateInstance(Type.GetType(ea.EditorTypeName));

            //return TypeDescriptor.GetEditor(propertyDescriptor.PropertyType, typeof(UITypeEditor)) as UITypeEditor;

            return propertyDescriptor.GetEditor(typeof(UITypeEditor)) as UITypeEditor;
        }

        /// <summary>
        /// prüft ob angegebene Eigenschaft <see cref="TypeConverterAttribute"/> gesetzt hat oder dessen Type
        /// </summary>
        /// <param name="instance">Instance aus der Eigenschaft stammt</param>
        /// <param name="propertyName">name der zu prüfenden Eigenschaft</param>
        /// <returns>true - <see cref="TypeConverterAttribute"/> ist gesetzt</returns>
        public static bool HasEditor(object instance, string propertyName)
        {
            return (GetEditor(instance, GetPropertyDescriptor(instance, propertyName)) != null);
        }

        #endregion

        /// <summary>
        /// <see cref="IWindowsFormsEditorService"/> Klasse zum behandeln des <see cref="UITypeEditor"/>
        /// </summary>
        private class WindowsFormsEditorService : System.Windows.Forms.Design.IWindowsFormsEditorService, IDisposable
        {
            internal WindowsFormsEditorService(Control parent)
            {
                this.parent = parent;
            }

            #region IWindowsFormsEditorService Members

            public void CloseDropDown()
            {
                if (dropDownControl != null)
                {
                    dropDownControl.Leave -= new EventHandler(control_Leave);

                    parent.Controls.Remove(dropDownControl);
                    dropDownControl = null;
                }
            }

            public void DropDownControl(System.Windows.Forms.Control control)
            {
                CloseDropDown();

                dropDownControl = control;

                parent.Controls.Add(control);

                control.BringToFront();
                control.Location = parent.PointToClient(Control.MousePosition);

                System.Drawing.Rectangle recParent = new System.Drawing.Rectangle(parent.Location, parent.Size);
                System.Drawing.Rectangle recControl = new System.Drawing.Rectangle(control.Location, control.Size);

                while (recParent.Bottom<recControl.Bottom)
                    recControl.Y--;
                while (recParent.Right < recControl.Right)
                    recControl.X--;

                control.Location = recControl.Location;
                control.Focus();

                control.Leave += new EventHandler(control_Leave);

                while (true) //Schleife damit Control nicht sofort wieder verschwindet
                {
                    Application.DoEvents();
                    if (dropDownControl == null)
                        break;
                }
            }

            void control_Leave(object sender, EventArgs e)
            {
                CloseDropDown();
            }

            public System.Windows.Forms.DialogResult ShowDialog(System.Windows.Forms.Form dialog)
            {
                return dialog.ShowDialog();
            }

            #endregion

            #region IDisposable Members

            public void Dispose()
            {
                CloseDropDown();
            }

            #endregion

            private readonly Control parent;
            private Control dropDownControl;
        }

        private readonly Control parent;
        private readonly Dictionary<string, UITypeEditor> uiTypeEditors;

        private WindowsFormsEditorService windowsFormsEditorService;
    }

Für TypeConverter:

   /// <summary>
    /// behandelt die TypeConverter der generierten Eigenschaften für das <see cref="PropertiesControl"/>
    /// </summary>
    internal class PropertiesControlTypeConverter : PropertiesControlTypeDescriptorContext
    {
        internal PropertiesControlTypeConverter(object instance)
            : base(instance)
        {
            this.typeConverters = new Dictionary<string, TypeConverter>();
        }

        /// <summary>
        /// liefert <see cref="TypeConverter"/> für akt. Eigenschaft (Eigenschaft wird gesetzt über <see cref="PropertiesControlTypeDescriptorContext.SetCurrentProperty"/>)
        /// </summary>
        private TypeConverter GetConverter()
        {
            TypeConverter tc;
            if (!typeConverters.TryGetValue(PropertyDescriptor.Name, out tc))
            {
                tc = GetConverter(Instance, PropertyDescriptor);
                typeConverters.Add(PropertyDescriptor.Name, tc);
            }
            return tc;
        }


        /// <summary>
        /// prüft ob akt. Eigenschaft (Eigenschaft wird gesetzt über <see cref="PropertiesControlTypeDescriptorContext.SetCurrentProperty"/>) <see cref="TypeConverter"/> gesetzt hat oder dessen Type
        /// </summary>
        /// <returns>true - <see cref="TypeConverter"/> ist gesetzt</returns>
        public bool HasConverter()
        {
            return (GetConverter() != null);
        }

        /// <summary>
        /// liefert Wert wie er angezeigt werden muss für akt. Eigenschaft (Eigenschaft wird gesetzt über <see cref="PropertiesControlTypeDescriptorContext.SetCurrentProperty"/>)
        /// </summary>
        /// <param name="value">akt. Wert aus Eigenschaft</param>
        /// <returns>Wert für Anzeige</returns>
        public virtual string GetPropertyTextValue(object value)
        {
            string str = null;
            try
            {
                str = GetConverter().ConvertToString(this, value);
            }
            catch (Exception)
            {
                //Exception durchfallen lassen kommt von Microsoft (aus: System.Windows.Forms.PropertyGridInternal.GridEntry.GetPropertyTextValue)
            }
            if (str == null)
            {
                str = string.Empty;
            }
            return str;
        }

        /// <summary>
        /// liefert Wert wie er in die Eigenschaft zurück geschrieben werden muss für akt. Eigenschaft (Eigenschaft wird gesetzt über <see cref="PropertiesControlTypeDescriptorContext.SetCurrentProperty"/>)
        /// </summary>
        /// <param name="str">akt. Wert laut Anzeige</param>
        /// <returns>Wert für Eigenschaft</returns>
        public virtual object SetPropertyTextValue(string str)
        {
            TypeConverter tc = GetConverter();
            if (tc.CanConvertFrom(this, typeof(string)))
            {
                return tc.ConvertFromString(this, str);
            }
            return str;
        }

        /// <summary>
        /// Returns whether this object supports a standard set of values that can be picked from a list, using the specified context.
        /// </summary>
        /// <returns>true if System.ComponentModel.TypeConverter.GetStandardValues() should be called to find a common set of values the object supports; otherwise, false.</returns>
        public bool GetStandardValuesSupported()
        {
            return GetConverter().GetStandardValuesSupported(this);
        }

        /// <summary>
        /// Returns a collection of standard values for the data type this type converter is designed for when provided with a format context.
        /// </summary>
        /// <returns>A ICollection that holds a standard set of valid values, or null if the data type does not support a standard set of values.</returns>
        public ICollection GetStandardValues()
        {
            return GetConverter().GetStandardValues(this);
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
                typeConverters.Clear();

            base.Dispose(disposing);
        }

        #region Statische Methoden

        /// <summary>
        /// liefert eine <see cref="TypeConverterAttribute"/> wenn gesetzt oder der Type der Eigenschaft dies gesetzt hat sonst null
        /// </summary>
        private static TypeConverter GetConverter(object instance, PropertyDescriptor propertyDescriptor)
        {
            //TypeConverterAttribute tca = null;
            //foreach (Attribute attr in propertyDescriptor.Attributes)
            //{
            //    if (attr is TypeConverterAttribute)
            //    {
            //        tca = (TypeConverterAttribute)attr;
            //        break;
            //    }
            //}

            //if (tca == null)
            //{
            //    object[] attrs = propertyDescriptor.PropertyType.GetCustomAttributes(typeof(TypeConverterAttribute), true);
            //    if (attrs.GetLength(0) > 0)
            //        tca = (TypeConverterAttribute)attrs[0];
            //}

            //if (tca != null)
            //{
            //    try
            //    {
            //        return (TypeConverter)Activator.CreateInstance(Type.GetType(tca.ConverterTypeName));
            //    }
            //    catch (MissingMethodException) //wenn kein Parameterloser Konstruktor (nur Parameter Type erlaubt)
            //    {
            //        return (TypeConverter)Activator.CreateInstance(Type.GetType(tca.ConverterTypeName), propertyDescriptor.PropertyType);
            //    }
            //}

            //return null;

            return propertyDescriptor.Converter;
        }

        /// <summary>
        /// prüft ob angegebene Eigenschaft <see cref="TypeConverterAttribute"/> gesetzt hat oder dessen Type
        /// </summary>
        /// <param name="instance">Instance aus der Eigenschaft stammt</param>
        /// <param name="propertyName">name der zu prüfenden Eigenschaft</param>
        /// <returns>true - <see cref="TypeConverterAttribute"/> ist gesetzt</returns>
        public static bool HasConverter(object instance, string propertyName)
        {
            return (GetConverter(instance, GetPropertyDescriptor(instance, propertyName)) != null);
        }

        #endregion

        private readonly Dictionary<string, TypeConverter> typeConverters;
    }

Im Prinzip dann nur SetCurrentProperty aufrufen mit HasEditor prüfen ob Editor angegeben wurde und mit EditValue kommt dann der Editor

du hast die Remove Methode mit new neu angelegt.

Die BindingSource kennt aber höchstens die Remove Methoden der List<T>,
deshalb wurden deine nie ausgelöst.

du musst in ZeigeFenster nicht zwingend Application.Run aufrufen
ein einfaches aufrufen von ShowDialog der form tuts auch.

.Net schaut intern ob schon eine Nachrichtenschleife läuft, wenn nicht wird intern entsprechend eine gestartet.

Das Enter Ereignis beachte ich natürlich auch mit.

Bei meinem Code gings nur noch um das Problem mit dem Mausklick das dort alles selektiert wird und nur wenn vorher noch kein Focus auf der Textbox vorhanden war.

Sry hat ich vergessen mit zu erwähnen.

P.S.: Die Gelbe Schrift ging bissl unter hab auch nicht gemerkt das der Thread schon 8 Jahre oder so alt ist, hatte mich mehr auf die Posts konzentriert.

hier mal ein ausschnitt aus einer meiner abgeleiteten Textboxen:

        protected override void WndProc(ref Message m)
        {
            bool isFocused = this.Focused;

            base.WndProc(ref m);

            if (!isFocused && m.Msg == 0x0201) //WM_LBUTTONDOWN
                OnMouseDownFirst(EventArgs.Empty);
        }

ich hab mir hier allerdings nochmal ein eigenes event MouseDownFirst gemacht welches ich abonniere.
Man könnte da allerdings auch schon direkt SelectAll() aufrufen.

Was oft vernachlästigt wird ist die Bedienbarkeit.

Wenn ich dich richtig verstehe ist das Programm für dich selbst auch neu.

Hier könntest du schon erste Eindrücke sammeln, ist das Programm leicht zu bedienen. Muss ich N Einstellungen, Häckschen setzen nur um irgendwas bestimmtes machen zu können...

Als programmierer kennt man seine Funktionen, sein Programm und achtet manchmal nicht direkt drauf ob das auch die "anderen" verstehen / intuitiv anwenden können.

Vorallem Programmodule die sich um die stammdatenpflege kümmern, wie hier Kundendaten erfassen, werden in der Regel eher weniger häufig verwendet (eigene subjektive Meinung).

Hier sollte es dem Bediener leicht gemacht werden sich schnell zurecht zu finden.

Sebastian, aus meiner Sicht und Erfahrung ist der geschlossene Stream das Problem und die Antwort auf die Frage.

Alles weitere sind nur Vermutungen, solange sich der Fragesteller nicht weiter äußerst und das Stream problem nicht beseitigt hat.

Sebastian bin mir zu 99,9 % sicher das das problem ist weil der Stream geschlossen wurde.
Selbst kopieren/klonen des Image Objektes bringt da nixs.

Wie herbivore richtig hervorhob, der Stream darf nicht vorher entsorgt werden solange das Image objekt noch benötigt wird.

du darfst den MemoryStream des Bildes nicht schließen,
durch das du das Image erstellt hast.

thx
Wollte den post eigentlich noch garnicht abschicken ^^
Aber die PDF schaut aufn ersten Blick gut aus.

Hi,
ich muss 2 Dokumente vergleichen und würde gerne Zeilenweise die Unterschiede/Änderungen aufzeigen.

Ähnlich wie es Wikipedia macht:
Anzeige eines Versionsunterschieds bei Wikipedia

Bisher habe ich schon Zeilenweise beide Dokumente eingelesen.
Die neuen und gelöschten Zeilen habe ich theoretisch auch schon gefiltert und kann diese Anzeigen.

Bisher ist dies jedoch blos ein einfacher String Equals vergleich.
Was ich gerne noch machen würde ist zu prüfen ob sich eventuell nur einzelne Wörter (meist wohl Datümer und Beträge) sich innerhalb der beiden Zeilen geändert haben.

Leider fehlen mir dazu auch die Stichwörter um per google selbst zu suchen.

Die Anzeige ist kein problem das mache ich mit C1PrintDocument.

Mir fehlt bissel die Idee wie ich nur einzelne Wörter filtern könnt, bis zu einem gewissen Grad um zu entscheiden ob dies eine neue Zeile ist oder sich nur 1, 2 Wörter innerhalb der beiden Zeilen geändert haben.

Vielleicht habt ihr ja paar Anhaltspunkte.

Falls von Interesse, verglichen werden 2 TXTextControl/ServerTextControl Controls/Componenten, also zur Not könnte ich auch über dortige Methoden gehen.

Aber was allgemeines wäre mir lieber.

Kurz gesagt, string Vergleich von 2 Texten und dabei nur die geänderten Wörter erkennen.

Meine einzige Idee wäre sonst höchstens einmal von Beginn an der Zeile zu prüfen und einmal vom Ende an der Zeile, wie weit sich diese beiden gleichen.

Aber geht das auch besser?

P.S.:
hm jetzt wo ich hier schreib fällt mir noch ein das ich einfach nach Leezeichen, Punkt und Komma splitten könnt und da die Wörter vergleich :\

Aber vielleicht hat doch noch jemand Ideen oder weitere Quellen die noch Anregungen bieten könnten.

den Anchor bei den Controls komplett rausnehmen und die Controls einfach auf dem Form mittig platzieren

Wie wäre eventuell es mit nem Präbuild Command
der die Uhrzeit vorher noch in eine Ressource schreibt?

Ist es nicht jetzt auch so, das so oder so alle Projekte neu kompiliert werden müssen (die diese DLL verwenden)?
Durch die geänderte Signatur ändert sich ja auch der Strongname?

Wie wichtig ist die GUID genau?
Eventuell wäre es besser eher den Typen des Containers + den Namen des Steuerelements auf dem Container zu merken und darüber die Hilfe zu referenzieren.
Bissel ähnlich/gleich wie es die XML Dokumentation vom VS macht.

Probier mal eine BindingSource zwischen zu schalten

act=new AktuelleWerte();
bindignSource.DataSource=act;

((ISupportInitialize)bindignSource).BeginInit();

tb_FilllevelTank.DataBindings.Add("Text", bindignSourcet, "FillLeveltank_Anzeige",false,DataSourceUpdateMode.OnPropertyChanged);

((ISupportInitialize)bindignSource).EndInit();

(bissl ausm kopf getippt)

Generic mit New ruft ja im Hintergrund nixs anderes wie Activator.CreateInstance auf.
Das kannst du auch selbst machen.
Schau die mal die Überladungen dafür an, dort gibts auch entsprechende Überladungen für Konstruktoren mit Parameter.
Als Typen einfach typeof(RessourceT) angeben.

Ich würde die Schnittstelle von IEquatable noch mit ableiten

interface IMeinInterface: IEquatable

Die standard Listen zum Beispiel prüfen eigentlich erstmal ob entsprechendes Equals gesetzt ist bevor diese einen Referenzvergleich durchführen.

In der Equals Methode würde ich dann einfach die Eigenschaften/Felder beider Objekte prüfen.

Und für dich selbst könntest du dann einfach über Equals vergleichen.

(Achtung bei den Objekten welche deine Schnittstelle implementieren müsste eventuell dennoch GetHashCode und Equals überschrieben werden, bin mir da gerade nicht sicher)

Oder eventuell P.S. (hab das mit der implementierung falschv erstanden):
Eventuell hilft DuckTyping was, such mal bei googeln nach (bei Codeproject müsste da glaube was sein)

Dann überspring doch das erneute hinzufügen zum Dictionary, wenn die Nummer schon vorhanden ist. Try-Catch könnte da schon helfen. Da kannst du die ArgumentException von Dictionary.Add abfangen und den Datensatz dann halt entsprechend nicht hinzufügen.

Dictionary bietet dafür extra schon ContainsKey oder TryGetValue Methoden an.

d!n3L Beispiels ist nicht schlecht und würde ich auch sofort so übernehmen.

Wenn man sich jedoch sein Screen anschaut, wird hier, denke ich mal, selbst auch ein modales Dialog für die Eingabe aufgerufen.
In so einem verkleinertem Fenster fällt auch sone Gelbe Warnmeldung sofort auf.

In einem maximierten Fenster mit mehreren Controls , Listen etc. kann solch eine Meldung aber schonmal unter gehen.
In solchem Fall bringe ich dann doch lieber eine MessageBox mit dem Hinweis inkorrekter Daten und zeige diese dann allerdings über ErrorProvider etc. bei den jeweiligen Controls an.

Gibt es denn Statistiken das die User eine MessageBox nicht wollen?
Oder reden wir hier eher von subjektiven Erfahrungen einiger weniger leute?

Ich finde das sollte man ev. bei der Diskussion mit beachten.

Klingt mir danach als wenn du immer die AssemblyVersion erhöht hast.
Erhöhe die Dateiversion dort gibts diese Abhängigkeitenprüfung nicht.

Schnittstelle ISupportInitialize setzen und im EndInit die DataSource zuweisen.

Oder auch DesignerSerializationAttribute mit Hidden angeben bei der Eigenschaft, wenn die DataSource eh nicht geändert werden darf.

(ist die Eigenschaft nicht überschreibbar würd ich mit new diese angeben)

zu Sperrung einer Software:

Hab ein Programm, wenn bestimmte Daten ankommen müssen einige sichtbare TabPages erstmal gesperrt werden, bis der User eine Aktion tätigt.

In diesem Fall packe ich jeweils ein Panel über die TabPages die zu diesem zeitpunkt sichtbar waren.

In diesen Panels ist jeweils ein Image mit dem vorher eine Art screenshots der Child Controls der TabPage gemacht wurde.
(Nicht ganz so kräftig gezeichnet wie die original Controls damit man erkennt das dieser bereich inaktiv ist)

Der User muss ein Button auf dem Panel betätigen damit dann diese TabPage wieder aktiv wird.

Das Panel packe ich einfach drüber um weitere eingabe controls auf billige art und weiße zu blockieren und ich muss mich auch nicht um eventuelle ContextMenüs kümmern.

So blockiere ich auch nicht sofort das komplette FOrmular.