Initialisieren mit Werten aus ausführender Klasse



  • Hallo !
    Es gibt da leider etwas, was ich nicht verstehe. Ich hab ein Prog das in Parameter-Klasse, Parameterdialog-Klasse, Parameterproxy-Klasse und die auswertende Hauptklasse gegliedert ist. Die Proxy-Klasse dient nun dem Daten-Austausch zwischen Parameter-Klasse und Parameter-Dialog-Klasse und irgendwie übergibt dann eine Instanz der Parameter-Klasse die Daten an die ausführende Funktion execute in der Hauptklasse. Funktioniert auch ganz gut.
    Bis auf eines.

    Ich bin nicht in der Lage den Parameter-Dialog mit den zuletzt verwendeten Parametern zu initialisieren, so dass man sieht, was man vor 5 Minuten eigentlich getan hat. Ich versteh nicht, was ich an der Proxy-Klasse oder dem Dialog ändern muss, damit nicht immer Standardwerte verwendet werden.
    Die Proxy-Instanz sollte meiner Meinung nach in beiden Richtungen funktionieren... tut aber nicht.

    Tatsächlich versteh ich nichtmal, ab wo die Instanz deklariert ist.
    Beim Öffnen des Dialogs wird die als privater Member angelegt, zeigt aber auf NULL. Ab wo das nicht mehr der Fall ist, kann ich einfach nicht finden. Lediglich beim Event btnok_click und dem Schließen des Dialogs sehe ich, dass die eingestellten Parameter übergeben werden.

    Kennt sich da wer aus?? ZU HÜLF !

    ///<summary>The parameter proxy class is used to exchange the data between the parameter class and the parameter dialog class.
        /// Furthermore the parameter proxy class is the base of the representation of the parameters within the quick edit table.</summary>
        public class NCImpDiffusionfilterParameterProxy : NeuroCheck.PlugInLib.UI.NcPICheckFunctionParameterProxyBase
        {
    
            // Reference to plugin parameter class
            private NCImpDiffusionfilterParameter m_ParaRef;
    
            ///<summary>Parameter ParaRef</summary>
            [System.ComponentModel.BrowsableAttribute(false)]
            public virtual NCImpDiffusionfilterParameter ParaRef
            {
                get
                {
                    return m_ParaRef;
                }
                set
                {
                    m_ParaRef = value;
                }
            }
    
            private Object m_Parameter;
    
            [DisplayName("Parameter")]
            [Category("Plug-in parameters")]
            public virtual Object Parameter
            {
                get
                {
                    return this.m_Parameter;
                }
                set
                {
                    this.m_Parameter = value;
                    base.IsModified = true;
                    base.CallUpdateController("Parameter", m_Parameter);
                }
            }
    
            ///<summary>Constructor</summary>
            public NCImpDiffusionfilterParameterProxy() : 
                    base()
            {
            }
    
            ///<summary>Constructor</summary>
            public NCImpDiffusionfilterParameterProxy(NCImpDiffusionfilterParameter dataClass) : 
                    this()
            {
                Assign(dataClass);
            }
    
            ///<summary>Updates the parameters in the plugin parameter class with these local copies</summary>
            public override void UpdateSourceObject()
            {
                m_ParaRef.Parameter = m_Parameter;
            }
    
            ///<summary>Assignes the parameter to the proxy object</summary>
            public virtual void Assign(NCImpDiffusionfilterParameter para)
            {
                m_ParaRef = para;
                m_Parameter = para.Parameter;
            }
    
            ///<summary>Returns a reference to the encapsulated parameter.</summary>
            public override NeuroCheck.PlugInLib.Base.NcPICheckFunctionParameterBase GetParameterForApply()
            {
                return ((NeuroCheck.PlugInLib.Base.NcPICheckFunctionParameterBase)(m_ParaRef));
            }
    
            ///<summary>Creates a copy of the check function parameter proxy members.</summary>
            public override object Clone()
            {
                NCImpDiffusionfilterParameterProxy cfParaProxy = new NCImpDiffusionfilterParameterProxy();
                base.CloneBaseMembers(cfParaProxy);
                cfParaProxy.ParaRef = m_ParaRef;
                cfParaProxy.m_Parameter = m_Parameter;
                return ((object)(cfParaProxy));
            }
        }
    }
    
    [Serializable()]
        public class NCImpDiffusionfilterParameter : NeuroCheck.PlugInLib.Base.NcPICheckFunctionParameterBase
        {
            private static DiffusionModell modelparams = new DiffusionModell();
    
            ///<summary>Constructor</summary>
            public NCImpDiffusionfilterParameter() : 
                    base()
            {
                try
                {
                    SetDefaultParameters();
                }
                catch (System.Exception )
                {
                    throw;
                }
            }
    
            ///<summary>Parameter Parameter</summary>
            public virtual Object Parameter
            {
                get
                {
                    return m_Parameter;
                }
                set
                {
                    m_Parameter = value;
                }
            }
    
            private Object m_Parameter;
    
            ///<summary>Deserialization routine for check function</summary>
            protected NCImpDiffusionfilterParameter(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) : 
                    base(info, context)
            {   try
                {
                    SetDefaultParameters();
                }
                catch (System.Exception )
                {
                    throw;
                }
                try
                {
                    DiffusionModell modelparams = (DiffusionModell) (info.GetValue("NC60_Imp_Diffusionfilter_NCImpDiffusionfilter_Parameter", typeof(DiffusionModell)));
                    //m_Parameter = ((Object)(info.GetValue("NC60_Imp_Diffusionfilter_NCImpDiffusionfilter_Parameter", typeof(Object))));
                }
                catch (System.Exception ex)
                {
                    NCImpDiffusionfilter.MissedItems.Add(new NeuroCheck.PlugInLib.Base.NcPIDeserializationItemDescription(typeof(Object), "m_Parameter", "NC60_Imp_Diffusionfilter_NCImpDiffusionfilter_Parameter"));
                }
            }
    
            ///<summary>Serialization routine for check function parameter.</summary>
            public override void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context)
            {
                base.GetObjectData(info, context);
                info.AddValue("NC60_Imp_Diffusionfilter_NCImpDiffusionfilter_Parameter", m_Parameter);
            }
    
            ///<summary>Parameter default value initialization.</summary>
            public virtual void SetDefaultParameters()
            {
                modelparams.homogen = false;
                modelparams.param1_imagebased = true;
                modelparams.param2_imagebased = true;
                modelparams.angles_imagebased = true;
                modelparams.L1constant = 1;
                modelparams.L2constant = 1;
                modelparams.isotrop = true;
                modelparams.anisotrop = false;
                modelparams.prefer_edges = false;
                modelparams.constAngle = 0;
                modelparams.Cmod = (int)DiffusionModell.function_nums.Cottet_Germain;
                modelparams.DiffusionConstant = 1.0;
                modelparams.iterations = 1;
                modelparams.k = 64;
                modelparams.LUT = modelparams.SETLUT(0, 64);
                modelparams.stopp_at = (int)DiffusionModell.stopper_nums.Filterbild;
                m_Parameter = modelparams;
                //m_Parameter = null;
            }
    
            public override object Clone()
            {
                NCImpDiffusionfilterParameter cfPara = new NCImpDiffusionfilterParameter();
                base.CloneBaseMembers(cfPara);
                cfPara.m_Parameter = m_Parameter;
                return ((object)(cfPara));
            }
        }
    
    ///<summary>The parameter dialog class implements a parameter dialog.
        /// The parameter dialog is used to enable the user to change the parameters of the check function via a graphical user interface.</summary>
        public class NCImpDiffusionfilterParameterDialog : NeuroCheck.PlugInLib.UI.NcPICheckFunctionDialogBase
        {
            private DiffusionModell getmodel = new DiffusionModell();
    
            // Reference to the parameter proxy object
            private NCImpDiffusionfilterParameterProxy m_ProxyInstance;
    
            ///<summary>Parameter ProxyInstance</summary>
            public virtual NCImpDiffusionfilterParameterProxy ProxyInstance
            {
                get
                {
                    return m_ProxyInstance;
                }
                set
                {
                    m_ProxyInstance = value;
                    //pgrdParameter.SelectedObject = m_ProxyInstance;
                }
            }
            private System.Windows.Forms.Button btnApply;
            public NCImpDiffusionfilterParameterDialog() : 
                    base()
            {
                InitializeComponent();
                // Verwendet Standard solange Proxy=NULL ::
                if (m_ProxyInstance != null) getmodel = (DiffusionModell)m_ProxyInstance.Parameter;
                else { /*m_ProxyInstance.Parameter = ProxyInstance.Parameter;*/ };
            }
            ///<summary>OK button was clicked.</summary>
            private void btnOK_Click(object sender, System.EventArgs e)
            {
                m_ProxyInstance.Parameter = (object)getmodel;
                m_ProxyInstance.UpdateSourceObject();
                Close();
            }
            ///<summary>Cancel button was clicked.</summary>
            private void btnCancel_Click(object sender, System.EventArgs e)
            {
                Close();
            }
            ///<summary>Help button was clicked.</summary>
            private void btnHelp_Click(object sender, System.EventArgs e)
            {
                NcPIHelp.Show("NC60_Imp_Diffusionfilter");
            }
            ///<summary>Apply button was clicked.</summary>
            private void btnApply_Click(object sender, System.EventArgs e)
            {
                m_ProxyInstance.Parameter = (object)getmodel;
                base.CallApplyCallback(m_ProxyInstance);
            }
            ///<summary>Form load event.</summary>
            private void FormLoaded(object sender, System.EventArgs e)
            {
                btnHelp.Visible = true;
                btnApply.Visible = true;
            }
            ///<summary>Dialog initialization.</summary>
    
            private void functiontype_Click(object sender, EventArgs e)
            {
                int ctype;
                ctype = functiontype.SelectedIndex;
                getmodel.Cmod = ctype;
                getmodel.LUT = getmodel.SETLUT(ctype, getmodel.k);
            }
    


  • Könntest du dein Code vielleicht auf die Stellen zu schneiden, die du meinst? Ich kau mich nicht durch ~900 Zeilen Code 😃 ...



  • Wenn ich beim Überfliegen alles richtige gesehen habe, dann hast du deine ParameterProxy-Klasse im ParameterDialog als Member. Wenn du den Paramter-Dialog schließt, ist damit auch die Instanz der Proxy-Klasse futsch. Du könntest die Proxy-Klasse bspw. als Singleton halten, dann könntest du die Daten von überall nutzen.



  • PuppetMaster2k schrieb:

    Wenn ich beim Überfliegen alles richtige gesehen habe, dann hast du deine ParameterProxy-Klasse im ParameterDialog als Member. Wenn du den Parameter-Dialog schließt, ist damit auch die Instanz der Proxy-Klasse futsch. Du könntest die Proxy-Klasse bspw. als Singleton halten, dann könntest du die Daten von überall nutzen.

    Sorry, dachte der Code sollte mögllichst komplett sein, damit man durchblickt. Hab jetzt alles gelöscht, was meiner Meinung nach überflüssig ist.

    Jo, in dem Dialog ist eine private Instanz und die geht automatisch futsch. Aber darauf kommts auch nicht an, wenn ich den Code richtig verstehe.
    Der Proxy hat als Inhalt die Parameterklasse. Wenn ich was reinkopiere bleibt der neue Inhalt irgendwie erhalten, das ist auf eine mir nicht nachvollziehbare Weise NICHT an die Instanz gebunden.
    Jedenfalls muss ich den Inhalt weder an einen gereften Schnittstellenparameter, noch an eine globale Variable übergeben (wenn sowas in c# überhaupt gibt). Theoretisch müsste der Inhalt also wech sein...Sorry aba ich nix verstehn Prinzip. 😕

    Die Grundfunktionalität hab ich von nem Plugin-Assistenten des Programms Neurocheck. Es SOLLTE so funktionieren wie Standardfunktionen. Und diese bewahren sich ihre Parametereinstellung. Ich weiss nur nicht wie, da ich weder Code noch ne gescheite Doku dazu hab.

    MFG



  • Hab jetzt raus, wann die Proxy-Instanz ungleich NULL wird. Wenn nach der Initialisierung des Dialogs ein erster beliebiger Event auftritt. Versteh nur nicht WARUM..
    Also hab ich als zusätzlichen Eventhandler ein DialogShown eingefügt und bin ab da theoretisch in der Lage den Inhalt des Proxys als Init der Anzeige zu übergeben.

    Stattdessen hab ich ein neues Problem. Wenn ich das nämlich mache funktioniert das Hauptprogramm nicht mehr. Änderungen der Parameter gehen irgendwo zwischen UpdateSourceObject() im Parameterdialog und der Übergabe von PlugInParameter in der execute-Funk des Hauptprogramms verloren ausser ich benutze die temporäre Applyfunktion.. 😕
    Die ist aber nur zum Angucken gut, das Prog insgesamt funzt nur mit btnok.


Log in to reply