The reference itself is basically a pointer.  32 bits on a 32 bit OS, 64 bits on a 64 bit OS.

The size of the object that&#39;s referenced is more complicated.

For determining pointer size, you can use `System.Runtime.InteropServices.Marshal.SizeOf(typeof(IntPtr))`, or `sizeof(IntPtr)` in unsafe context.

Edit:

Or `IntPtr.Size`.

An object reference is basically a pointer to the memory that contains the object&#39;s attributes. As such the reference is one processor word in length - 32 bits on 32 bit platforms and 64 bits on x64.

I have two tables, with a same column named `user_name`, saying `table_a`, `table_b`.

I want to, copy from `table_b`, `column_b_1`, `column_b2`, to `table_b1`, `column_a_1`, `column_a_2`, respectively, where the `user_name` is the same, how to do it in SQL statement?

Update table values from another table with the same user name

What is the quickest/best way to change a large number of columns to numeric from factor? 

I used the following code but it appears to have re-ordered my data.

    &gt; head(stats[,1:2])
      rk                 team
    1  1 Washington Capitals*
    2  2     San Jose Sharks*
    3  3  Chicago Blackhawks*
    4  4     Phoenix Coyotes*
    5  5   New Jersey Devils*
    6  6   Vancouver Canucks*

    for(i in c(1,3:ncol(stats))) {
    	stats[,i] &lt;- as.numeric(stats[,i])
    }

    &gt; head(stats[,1:2])
      rk                 team
    1  2 Washington Capitals*
    2 13     San Jose Sharks*
    3 24  Chicago Blackhawks*
    4 26     Phoenix Coyotes*
    5 27   New Jersey Devils*
    6 28   Vancouver Canucks*


What is the best way, short of naming every column as in:

    df$colname &lt;- as.numeric(ds$colname)

Change the class from factor to numeric of many columns in a data frame

What is the size of an object reference in .NET?  Does it vary between x86, x64, and/or AnyCPU compilation?

If it makes a difference, I&#39;m interested in C#.


How big is an object reference in .NET?

<p>What is the size of an object reference in .NET?  Does it vary between x86, x64, and/or AnyCPU compilation?</p>
<p>If it makes a difference, I'm interested in C#.</p>


Can anybody suggest how I can convert an image to a byte array and vice versa? 

I&#39;m developing a WPF application and using a stream reader.


How to convert image to byte array

I lately had the problem of creating add and edit dialogs for my wpf app.

All I want to do in my code was something like this. (I mostly use viewmodel first approach with mvvm)

ViewModel which calls a dialog window:

    var result = this.uiDialogService.ShowDialog(&quot;Dialogwindow Title&quot;, dialogwindowVM);
    // Do anything with the dialog result

How does it work?

First, I created a dialog service:

    public interface IUIWindowDialogService
    {
        bool? ShowDialog(string title, object datacontext);
    }

    public class WpfUIWindowDialogService : IUIWindowDialogService
    {
        public bool? ShowDialog(string title, object datacontext)
        {
            var win = new WindowDialog();
            win.Title = title;
            win.DataContext = datacontext;

            return win.ShowDialog();
        }
    }

`WindowDialog` is a special but simple window.  I need it to hold my content:

    &lt;Window x:Class=&quot;WindowDialog&quot;
        xmlns=&quot;http://schemas.microsoft.com/winfx/2006/xaml/presentation&quot; 
        Title=&quot;WindowDialog&quot; 
        WindowStyle=&quot;SingleBorderWindow&quot; 
        WindowStartupLocation=&quot;CenterOwner&quot; SizeToContent=&quot;WidthAndHeight&quot;&gt;
        &lt;ContentPresenter x:Name=&quot;DialogPresenter&quot; Content=&quot;{Binding .}&quot;&gt;
        
        &lt;/ContentPresenter&gt;
    &lt;/Window&gt;

A problem with dialogs in wpf is the `dialogresult = true` can only be achieved in code.  That&#39;s why I created an interface for my `dialogviewmodel` to implement it. 

    public class RequestCloseDialogEventArgs : EventArgs
    {
        public bool DialogResult { get; set; }
        public RequestCloseDialogEventArgs(bool dialogresult)
        {
            this.DialogResult = dialogresult;
        }
    }

    public interface IDialogResultVMHelper
    {
        event EventHandler&lt;RequestCloseDialogEventArgs&gt; RequestCloseDialog;
    }

Whenever my ViewModel thinks it&#39;s time for `dialogresult = true`, then raise this event.

    public partial class DialogWindow : Window
    {
        // Note: If the window is closed, it has no DialogResult
        private bool _isClosed = false;

        public DialogWindow()
        {
            InitializeComponent();
            this.DialogPresenter.DataContextChanged += DialogPresenterDataContextChanged;
            this.Closed += DialogWindowClosed;
        }

        void DialogWindowClosed(object sender, EventArgs e)
        {
            this._isClosed = true;
        }

        private void DialogPresenterDataContextChanged(object sender,
                                  DependencyPropertyChangedEventArgs e)
        {
            var d = e.NewValue as IDialogResultVMHelper;

            if (d == null)
                return;

            d.RequestCloseDialog += new EventHandler&lt;RequestCloseDialogEventArgs&gt;
                                        (DialogResultTrueEvent).MakeWeak(
                                            eh =&gt; d.RequestCloseDialog -= eh;);
        }

        private void DialogResultTrueEvent(object sender, 
                                  RequestCloseDialogEventArgs eventargs)
        {
            // Important: Do not set DialogResult for a closed window
            // GC clears windows anyways and with MakeWeak it
            // closes out with IDialogResultVMHelper
            if(_isClosed) return;

            this.DialogResult = eventargs.DialogResult;
        }
     }

Now at least I have to create a `DataTemplate` in my resource file(`app.xaml` or something):

    &lt;DataTemplate DataType=&quot;{x:Type DialogViewModel:EditOrNewAuswahlItemVM}&quot; &gt;
            &lt;DialogView:EditOrNewAuswahlItem/&gt;
    &lt;/DataTemplate&gt;

Well thats all, I can now call dialogs from my viewmodels:

     var result = this.uiDialogService.ShowDialog(&quot;Dialogwindow Title&quot;, dialogwindowVM);

Now my question, do you see any problems with this solution?


Edit: for completeness. The ViewModel should implement `IDialogResultVMHelper` and then it can raise it within a `OkCommand` or something like this:

    public class MyViewmodel : IDialogResultVMHelper
    {
        private readonly Lazy&lt;DelegateCommand&gt; _okCommand;

        public MyViewmodel()
        {
             this._okCommand = new Lazy&lt;DelegateCommand&gt;(() =&gt; 
                 new DelegateCommand(() =&gt; 
                     InvokeRequestCloseDialog(
                         new RequestCloseDialogEventArgs(true)), () =&gt; 
                             YourConditionsGoesHere = true));
        }

        public ICommand OkCommand
        { 
            get { return this._okCommand.Value; } 
        }

        public event EventHandler&lt;RequestCloseDialogEventArgs&gt; RequestCloseDialog;
        private void InvokeRequestCloseDialog(RequestCloseDialogEventArgs e)
        {
            var handler = RequestCloseDialog;
            if (handler != null) 
                handler(this, e);
        }
     }


EDIT 2: I used the code from here to make my EventHandler register weak:  
http://diditwith.net/2007/03/23/SolvingTheProblemWithEventsWeakEventHandlers.aspx  
(Website no longer exists, [WebArchive Mirror][1])


    public delegate void UnregisterCallback&lt;TE&gt;(EventHandler&lt;TE&gt; eventHandler) 
        where TE : EventArgs;

    public interface IWeakEventHandler&lt;TE&gt; 
        where TE : EventArgs
    {
        EventHandler&lt;TE&gt; Handler { get; }
    }

    public class WeakEventHandler&lt;T, TE&gt; : IWeakEventHandler&lt;TE&gt; 
        where T : class 
        where TE : EventArgs
    {
        private delegate void OpenEventHandler(T @this, object sender, TE e);

        private readonly WeakReference mTargetRef;
        private readonly OpenEventHandler mOpenHandler;
        private readonly EventHandler&lt;TE&gt; mHandler;
        private UnregisterCallback&lt;TE&gt; mUnregister;

        public WeakEventHandler(EventHandler&lt;TE&gt; eventHandler,
                                    UnregisterCallback&lt;TE&gt; unregister)
        {
            mTargetRef = new WeakReference(eventHandler.Target);

            mOpenHandler = (OpenEventHandler)Delegate.CreateDelegate(
                               typeof(OpenEventHandler),null, eventHandler.Method);

            mHandler = Invoke;
            mUnregister = unregister;
        }

        public void Invoke(object sender, TE e)
        {
            T target = (T)mTargetRef.Target;

            if (target != null)
                mOpenHandler.Invoke(target, sender, e);
            else if (mUnregister != null)
            {
                mUnregister(mHandler);
                mUnregister = null;
            }
        }

        public EventHandler&lt;TE&gt; Handler
        {
            get { return mHandler; }
        }

        public static implicit operator EventHandler&lt;TE&gt;(WeakEventHandler&lt;T, TE&gt; weh)
        {
            return weh.mHandler;
        }
    }

    public static class EventHandlerUtils
    {
        public static EventHandler&lt;TE&gt; MakeWeak&lt;TE&gt;(this EventHandler&lt;TE&gt; eventHandler, 
                                                        UnregisterCallback&lt;TE&gt; unregister)
            where TE : EventArgs
        {
            if (eventHandler == null)
                throw new ArgumentNullException(&quot;eventHandler&quot;);

            if (eventHandler.Method.IsStatic || eventHandler.Target == null)
                throw new ArgumentException(&quot;Only instance methods are supported.&quot;,
                                                &quot;eventHandler&quot;);

            var wehType = typeof(WeakEventHandler&lt;,&gt;).MakeGenericType(
                              eventHandler.Method.DeclaringType, typeof(TE));

            var wehConstructor = wehType.GetConstructor(new Type[] 
                                 { 
                                     typeof(EventHandler&lt;TE&gt;), typeof(UnregisterCallback&lt;TE&gt;) 
                                 });

            IWeakEventHandler&lt;TE&gt; weh = (IWeakEventHandler&lt;TE&gt;)wehConstructor.Invoke(
                                            new object[] { eventHandler, unregister });

            return weh.Handler;
        }
    }


  [1]: http://web.archive.org/web/20140319163345/http://diditwith.net/2007/03/23/SolvingTheProblemWithEventsWeakEventHandlers.aspx

Good or bad practice for Dialogs in wpf with MVVM?

I have an asp.net application, and now I am using datasets for data manipulation. I recently started to convert this dataset to a List collection. But, in some places it doesn&#39;t work. One is that in my old version I am using `datarow[] drow =  dataset.datatable.select(searchcriteria)`. But in the List collection there is no method available for finding particular values. Is there any way for me to select some values according with my search criteria? I want to know if this is possible. Please help me.


Select method in List&lt;t&gt; Collection

Assuming dictionary keys and values have their equals and hash methods implemented correctly, what is the most succinct and efficient way to test for equality of two dictionaries?

In this context, two dictionaries are said to be equal if they contain the same set of keys (order not important), and for every such key, they agree on the value.

Here are some ways I came up with (there are probably many more):

    public bool Compare1&lt;TKey, TValue&gt;(
        Dictionary&lt;TKey, TValue&gt; dic1, 
        Dictionary&lt;TKey,TValue&gt; dic2)
    {
        return dic1.OrderBy(x =&gt; x.Key).
            SequenceEqual(dic2.OrderBy(x =&gt; x.Key));
    }

    public bool Compare2&lt;TKey, TValue&gt;(
        Dictionary&lt;TKey, TValue&gt; dic1, 
        Dictionary&lt;TKey, TValue&gt; dic2)
    {
        return (dic1.Count == dic2.Count &amp;&amp; 
            dic1.Intersect(dic2).Count().
            Equals(dic1.Count));
    }

    public bool Compare3&lt;TKey, TValue&gt;(
        Dictionary&lt;TKey, TValue&gt; dic1, 
        Dictionary&lt;TKey, TValue&gt; dic2)
    {
        return (dic1.Intersect(dic2).Count().
            Equals(dic1.Union(dic2).Count()));
    }

Testing for equality between dictionaries in C#

This is allowed:

    int a, b, c;
    a = b = c = 16;

    string s = null;
    while ((s = &quot;Hello&quot;) != null) ;

To my understanding, assignment `s = ”Hello”;` should only cause `“Hello”` to be assigned to `s`, but the operation shouldn’t return any value. If that was true, then `((s = &quot;Hello&quot;) != null)` would produce an error, since `null` would be compared to nothing.  

What is the reasoning behind allowing assignment statements to return a value?


Why do assignment statements return a value?

Simple curiosity here, tinged with some practical concerns because I get caught out by this occasionally.

How come [`Color.DarkGray`](https://msdn.microsoft.com/en-us/library/system.drawing.color.darkgray) is lighter than [`Color.Gray`](https://msdn.microsoft.com/en-us/library/system.drawing.color.gray)?

Why is DarkGray lighter than Gray?

What is the difference between the `internal` and `private` access modifiers in C#?

Internal vs. Private Access Modifiers

 
Can anybody tell me how to remove all CA2202 warnings from the following code?     


    public static byte[] Encrypt(string data, byte[] key, byte[] iv)
    {
        using(MemoryStream memoryStream = new MemoryStream())
        {
            using (DESCryptoServiceProvider cryptograph = new DESCryptoServiceProvider())
            {
                using (CryptoStream cryptoStream = new CryptoStream(memoryStream, cryptograph.CreateEncryptor(key, iv), CryptoStreamMode.Write))
                {
                    using(StreamWriter streamWriter = new StreamWriter(cryptoStream))
                    {
                        streamWriter.Write(data);
                    }
                }
            }
            return memoryStream.ToArray();
        }
    }


&gt; Warning	7	CA2202 : Microsoft.Usage : Object &#39;cryptoStream&#39; can be disposed more than once in method &#39;CryptoServices.Encrypt(string, byte[], byte[])&#39;. To avoid generating a System.ObjectDisposedException you should not call Dispose more than one time on an object.: Lines: 34   
&gt;	
&gt; Warning	8	CA2202 : Microsoft.Usage : Object &#39;memoryStream&#39; can be disposed more than once in method &#39;CryptoServices.Encrypt(string, byte[], byte[])&#39;. To avoid generating a System.ObjectDisposedException you should not call Dispose more than one time on an object.: Lines: 34, 37	

You need Visual Studio Code Analysis to see these warnings (these are not c# compiler warnings).


CA2202, how to solve this case

I have a project that builds in 32/64-bit and has corresponding 32/64-bit dependencies.  I want to be able to switch configurations and have the correct reference used, but I don&#39;t know how to tell Visual Studio to use the architecture-appropriate dependency.

Maybe I&#39;m going about this the wrong way, but I want to be able to switch between x86 and x64 in the configuration dropdown, and have the referenced DLL be the right bitness.

Conditionally use 32/64 bit reference when building in Visual Studio

I have preferences where you can enable/disable what items will show up on the menu.  There are 17 items.  I made a string array in values/arrays.xml with titles for each of these 17 items.

I have preferences.xml which has the layout for my preferences file, and I would like to reference a single item from the string array to use as the title.

How can I do this?

In the Android developer reference, I see how I can reference a single string with XML, but not how I can reference a string from an array resource in XML.

Referencing a string in a string array resource with xml

I am getting this error:

&gt; The type or namespace name &#39;AutoMapper&#39; could not be found (are you missing a using directive or an assembly reference?)

The funny thing is that I have that reference in my project already:

![ProjectThatFails][1]

And this is my code:

    using System.Collections.Generic;
    using DataContract;
    using SelectorDAL;
    using AutoMapper;
    
    namespace SpecimenSelect
    {
        public class SpecimenSelect : ISpecimenSelect
        {
            public SpecimenSelect()
            {
                SetupMaps();
            }
    
            private static void SetupMaps()
            {
                Mapper.CreateMap&lt;SpecimenDetail, SpecimenDetailContract&gt;();
            }


The other weird thing is that I have two other projects in my solution that both use AutoMapper and are referencing the exact same AutoMapper.dll file.  They both work perfectly fine.

Here is a screen shot of one:

![ProjectThatWorks][2]

and here is that code (that compiles fine):

    using System.Collections.Generic;
    using AutoMapper;
    using DataContract;
    using SelectorDAL;
    
    namespace PatientSelect
    {
        
        public class PatientSelect : IPatientSelect
        {
            public PatientSelect()
            {
                SetupMaps();
            }
    
            private void SetupMaps()
            {
                Mapper.CreateMap&lt;Patient, PatientContract&gt;();
                Mapper.CreateMap&lt;OrderedTest, OrderedTestsContract&gt;();
                Mapper.CreateMap&lt;Gender, GenderContract&gt;();
            }

Both references seem to have the same data on the properties page.

What am I missing?

I tried:

 1. Restarting Visual Studio
 2. Referencing without a using statement (ie `AutoMapper.Mapper.CreateMap`)
 3. Clean and Rebuild

Any other ideas?

  [1]: http://i.stack.imgur.com/lbFBZ.png
  [2]: http://i.stack.imgur.com/EDUyh.png

Namespace not recognized (even though it is there)

I have a C# solution with two projects: a service (the main project) and a logger. The service uses classes from the logger. I&#39;ve added a Reference to the logger project within the service project. At design time, autocomplete works fine: the logger&#39;s classes are visible, references that I use are colored appropriately.

I Rebuild the solution, and things go wrong. The references are no longer recognized: &quot;The name &#39;Logging&#39; does not exist in the current context&#39; and the classes no longer exist in autocomplete. Removing and reattaching the reference gets me back to the base state of having the identifiers visible to autocomplete.

I&#39;ve rebooted, cleared all caches, made sure this is the only instance of VS 2010 running on my machine.

Is there something obvious (obviously) that I&#39;m missing?

Referenced Project gets &quot;lost&quot; at Compile Time

Does C have references? i.e. as in C++ :

    void foo(int &amp;i)

Does C have references?

I keep getting the same issue over and over again where an object I want to reference is copied or where an object I want to copy is referenced. This happens when I use the = operator.

For example, if I am sending the object to another form, ie: 

    SomeForm myForm = new SomeForm();
    SomeObject myObject = new SomeObject();
    myForm.formObject = myObject;

...and then modify the object in the form, the original object does not get modified. It is as if the object was copied and not referenced. Yet, when I do this:

    SomeObject myObject = new SomeObject();
    SomeObject anotherObject = new SomeObject();
    anotherObject = myObject;

...and then modify `anotherObject`, `myObject` gets modified as well.

The most aggravating case is when I try to Clone one of my defined objects:

    public class SomeObject
    {
        double value1, value2;
    
        //default constructor here
    
        public SomeObject(val1, val2)
        {
            value1 = val1;
            value2 = val2;
        }
    
        public void Clone(SomeObject thingToCopy)
        {
            this.value1 = thingToCopy.value1;
            this.value2 = thingToCopy.value2;
        }
    }

when I do this...

    SomeObject obj1 = new SomeObject(1, 2);
    SomeObject obj2 = new SomeObject();
    obj2.Clone(obj1);

...`obj1` is referenced and any modifications to `obj2` changes `obj1`.

System objects such as &lt;code&gt;int, double, string&lt;/code&gt;, etc seem to always be copied, except for in the case of the clone method above.

My question is, not taking into account the use of the &lt;code&gt;ref&lt;/code&gt; keyword in functions, when does an object get copied and when does an object get referenced in every case of the matter (i.e. when passing to functions, when setting as other objects (like the first two above examples), when copying member variables like the third example, etc.)?

Content Type	Original Author	Original Content on Stackoverflow
Question	Matt Mills	View Question on Stackoverflow
Solution 1 - C#	Samuel Neff	View Answer on Stackoverflow
Solution 2 - C#	IS4	View Answer on Stackoverflow
Solution 3 - C#	Igor Zevaka	View Answer on Stackoverflow

How big is an object reference in .NET?

C# Problem Overview

C# Solutions

Solution 1 - C#

Solution 2 - C#

Solution 3 - C#

Change the class from factor to numeric of many columns in a data frame

Update table values from another table with the same user name

Attributions