C#

class Program
{
    class MyClass
    {
        public int x;
    }

    static void changeMyClass1(MyClass myClass )
    {
        myClass.x = 100;
    }

    static void changeMyClass2(ref MyClass myClass )
    {
        myClass.x = 100;
    }

    static void Main(string[] args)
    {
        MyClass instance1 = new MyClass();
        MyClass instance2 = new MyClass();

        instance1.x = 0;
        instance2.x = 0;

        changeMyClass1(instance1);
        changeMyClass2(ref instance2);

        Console.WriteLine(instance1.x);//outputs 100
        Console.WriteLine(instance2.x);//outputs 100
    }
}

Malcolm Smart wrote:

Like CG said, they are by ref, by default. Both instances will change.

static void changeMyString1(string myString)
        {
            myString = mystring + " worked";
        }

        static void changeMyString2(ref string myString)
        {
            myString = mystring + " worked"; 
        }

int global = 10;

void Test()
{
   int val = 0;
   
   int *p = &val;
   Method2(p); // *p = 0;
   Method1(&p); // *p = 10
}

void Method1(int **p)
{
  *p = &g;
}

void Method2(int *p)
{
   p = &g;
}

Christian Graus wrote:

You have the ref keyword but it only works on value types. You can put 'ref' on a class param, but it makes no difference, it was a reference to start with

<configuration>
	<configSections>
		<section name="ClassMap" type="System.Configuration.SingleTagSectionHandler" />
		<section name="service1" type="System.Configuration.NameValueSectionHandler" />
		<section name="service2" type="System.Configuration.NameValueSectionHandler" />
	</configSections>
 
	<ClassMap
		service1="Service.Service1"
		service2="Service.Service2" />
 
	<!-- Service 1 -->
	<Service1>
		<!-- settings -->
	</Service1>
 
	<!-- Service 2 -->
	<Service2>
		<!-- settings -->
	</Service2>
 
	<!-- Global Application Settings -->
	<appSettings>
		<!-- settings -->
	</appSettings>
 
</configuration>

public BaseProcessor( string serviceName )<br />
{<br />
	config = (NameValueCollection)ConfigurationManager.GetSection(serviceName);<br />
}

Hashtable ClassMap = (Hashtable)ConfigurationManager.GetSection("ClassMap");<br />
foreach (string key in ClassMap.Keys)<br />
{<br />
BaseProcessor proc = (BaseProcessor)ClassFactory.Create(ClassMap[key].ToString(), key);<br />
}<br />
<br />

<appSettings>
	<!-- =============================================================================
	The following values are common among all services. Applicable settings might 
	be an smtp server address, and things like that. 
	============================================================================== -->
	<add key="SmtpServer" value="12.345.678.9"/>
	<add key="FromAddress" value="my.address@mydomain.com"/>
	<add key="NotifyAddress" value="notified@notifydomain.com"/>
	<add key="FfmpegPath" value="c:\program files\ffmpeg\ffmpeg.exe"/>
	<add key="DeferValidation" value="false"/>
	<add key="AllowDebugLaunch" value="false"/>

	<!-- =============================================================================
	The following values are unique among all services. Each service might have it's 
	own value for Test1. Values you might want to include here are things like the 
	event log name, a timeout value, service-specific folders, and things like that.
	============================================================================== -->
	<add key="Service1_EventLogName" value="Service1_Log"/>
	<add key="Service1_UploadPath" value="C:\Upload\Service1"/>
	<add key="Service1_AllowDebugLaunch" value="true"/>

	<add key="Service2_EventLogName" value="Service2_Log"/>
	<add key="Service2_UploadPath" value="C:\Upload\Service2"/>
	<add key="Service2_DeferValidation" value="true"/>
	<add key="Service2_UniqueSetting" value="12345"/>
</appSettings>

//--------------------------------------------------------------------------------
/// <summary>
/// Returns the prefix-adjusted key name. If IgnoreConfigPrefix is false, 
/// it returns the specified name without any changes
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
protected string KeyName(string name)
{
	return (IgnoreConfigPrefix) ? name : string.Format("{0}{1}", ConfigPrefix, name);
}

//--------------------------------------------------------------------------------
/// <summary>
/// Retrieves the specified value from the app.config file (this method 
/// simply allows the programmer to do less typing in order to load a 
/// value from the app.config file).
/// </summary>
/// <param name="keyName">The key name of the desired value</param>
/// <returns>The value retrieved, or an empty string if the key doesn't exist</returns>
protected string GetValue(string key)
{
	string value = "";
	// first, we try it with the config prefix 
	if (ConfigurationManager.AppSettings[KeyName(key)] != null)
	{
		value = ConfigurationManager.AppSettings[KeyName(key)].ToString().Trim();
	}
	else
	{
		// the prefixed key didn't exist, so look for the non-prefixed key
		// save the state of the ignore toggle
		bool m_oldIgnore = m_ignoreConfigPrefix;
		// ignore whatever prefix has been specified
		m_ignoreConfigPrefix = true;
		// try to load the key value
		if (ConfigurationManager.AppSettings[KeyName(key)] != null)
		{
			value = ConfigurationManager.AppSettings[KeyName(key)].ToString().Trim();
		}
		// restore the ignore toggle state
		m_ignoreConfigPrefix = m_oldIgnore;
	}
	return value;
}

If (_isOpened)
 return;

private bool _isOpen;

public class FormManager
    {
        // Main Form
        private MainForm mainForm;

        public FormManager(MainForm mainForm)
        {
            this.mainForm = mainForm;
        }

        public virtual System.Windows.Forms.Form GetForm(Type type, object[] args)
        {
            return GetMDIForm(type, args);
        }

        private ChildForm GetChildMDIForm(Type type)
        {
            // Try to get form of type 'type' from MdiChildren in mainForm
            for (int i = 0; i < mainForm.MdiChildren.Length; i++)
            {
                if (mainForm.MdiChildren[i].GetType().Equals(type))
                {
                    return (ChildForm)mainForm.MdiChildren[i];
                }
            }
            return null;
        }
        public virtual ChildForm GetMDIForm(Type type, object[] args)
        {
            ChildForm form = null;
            bool allowMultiple = false;

            // Attribute to decide whether multiple instance of form is allowed.
            object[] attributes = type.GetCustomAttributes(typeof(ChildFormAttribute), false);
            if (attributes.Length > 0)
            {
                allowMultiple = ((ChildFormAttribute)attributes[0]).AllowMulti;
            }

            if (!allowMultiple) // Not allow to create multiple
            {
                //Try to get from MDI Content
                form = GetChildMDIForm(type);
            }

            if (form == null)
            {
                form = CreateChildMDIForm(type, args);
                if (form != null)
                {
                    form.MdiParent = mainForm;
                    form.WindowState = FormWindowState.Maximized;
                    form.Show()
                }
                else
                {
                    throw new Exception(string.Format("Unable to create form of type '{0}'", type.ToString()));
                }
            }
            else
            {
                form.BringToFront();
            }

            return form;
        }
        private ChildForm CreateChildMDIForm(Type type, object[] args)
        {
            // Try to create a new form with args
            ConstructorInfo ci = type.GetConstructor(System.Type.EmptyTypes);
            ChildForm form = (ChildForm)ci.Invoke(args);
            return form;
        }

        public void ShowRole()
        {
            // Singleton class for opening new form or bring existing form to front
            Wine.Global.FormManager.Instance.GetForm(typeof(Wine.UI.Role), null);
        }

    }

    [ChildFormAttribute(false)] //<---- Use Attribute to indicate this form can not be multiple
    public partial class Role : ChildForm
    {
        public Role()
            : base()
        {
            InitializeComponent();
        }

    }

    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
    public class ChildFormAttribute : System.Attribute
    {
        private bool allowMulti;
        public bool AllowMulti
        {
            get
            {
                return allowMulti;
            }
        }

        public ChildFormAttribute(bool allowMulti)
        {
            this.allowMulti = allowMulti;
        }
    }

George_George wrote:

What means the assemblies?

George_George wrote:

For the following sample, why creates two XMLSerializer instances, one is s and the other is ser?