You should add **[BindingFlags.DeclaredOnly][1]** to your flags, i.e: 

    typeof(Child).GetProperties(System.Reflection.BindingFlags.Public
        | System.Reflection.BindingFlags.Instance
        | System.Reflection.BindingFlags.DeclaredOnly)


  [1]: http://msdn.microsoft.com/en-us/library/system.reflection.bindingflags.aspx

Try using the DeclaredOnly binding flag. It should limit the properties returned to only those declared on the class you are interested in. 
And here is a code sample:

    PropertyInfo[] properties = typeof(Child).GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.DeclaredOnly);

From **Type.cs**  : In this case use the DeclaredOnlyLookup  


      private const BindingFlags DefaultLookup = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public;
      internal const BindingFlags DeclaredOnlyLookup = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly;

Given:

    &lt;img src=&quot;...&quot;/&gt;
    &lt;img src=&quot;...&quot;/&gt;

The result is two images with a single space between them. It seems that the normal behavior is to show any number of spaces, newlines, and tabs as a single white space. I know I can do the following:

    &lt;img src=&quot;...&quot;/&gt;&lt;img src=&quot;...&quot;/&gt;

OR

    &lt;img src=&quot;...&quot;/&gt;&lt;!--
    --&gt;&lt;img src=&quot;...&quot;/&gt;

OR

    &lt;img src=&quot;...&quot;/
    &gt;&lt;img src=&quot;...&quot;/&gt;

Or any number of other hacks. Is there a way to remove that whitespace with CSS? e.g.

    &lt;div class=&quot;nospace&quot;&gt;
        &lt;img src=&quot;...&quot;/&gt;
        &lt;img src=&quot;...&quot;/&gt;
    &lt;/div&gt;



Use CSS to remove the space between images

&gt; **Possible Duplicate:**  
&gt; [What does the exclamation mark do before the function?](https://stackoverflow.com/questions/3755606/what-does-the-exclamation-mark-do-before-the-function)  

&lt;!-- End of automatically inserted text --&gt;

I&#39;ve long used the following for self-executing, anonymous functions in JavaScript:

    (function () { /* magic happens */ })()

Lately, I&#39;ve started seeing more instances of the following pattern (e.g., in [Bootstrap][1]):

    !function () { /* presumably the same magic happens */ }()

Anyone know what the advantage is of the second pattern? Or, is it just a stylistic preference?


  [1]: https://github.com/twitter/bootstrap/blob/master/js/bootstrap-alerts.js

In JavaScript, what is the advantage of !function(){}() over (function () {})()?

    class Parent {
       public string A { get; set; }
    }
    
    class Child : Parent {
       public string B { get; set; }
    }

I need to get only property B, without property A
 but

    Child.GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance)

return both properties :/

Get by reflection properties of class ,but not from inherited class

<pre><code class="hljs language-csharp">class Parent {
 public string A { get; set; }
}

class Child : Parent {
 public string B { get; set; }
}
</code></pre>
I need to get only property B, without property A
but
<pre><code class="hljs language-scss">Child.GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance)
</code></pre>
return both properties :/

I receive a string that contains valid JSON from another service.
I would like to just forward this string with Nancy but also set the content-type to &quot;application/json&quot; which will allow me to remove the need for using $.parseJSON(data) on the client side.

If I use Response.AsJson it seems to mangle the JSON in the string and adds escape characters.
I could create a Stream with the string and set the response type something like:

    Response test = new Response();
    test.ContentType = &quot;application/json&quot;;
    test.Contents = new MemoryStream(Encoding.UTF8.GetBytes(myJsonString)); 

but would like to know if there is a simpler way? 

Returning a string containing valid Json with Nancy

Can someone explain `Activator.CreateInstance()` purpose in detail?

Purpose of Activator.CreateInstance with example?

I have a string &quot;4,6,8\n9,4&quot;

I want to split this based on ,and \n

Output array should be 

    4
    6
    8
    9
    4

**Edit :**

 Now i am reading string from console , when i enter a string as above in console , in the code behind i get as `&quot;4,6,8\\n9,4&quot;` . Now that i want to split using `&quot;,&quot; and &quot;\\n&quot;` . How can i change the expression ? 

splitting a string based on multiple char delimiters

&gt; **Possible Duplicate:**  
&gt; [ASP.net get the next tuesday](https://stackoverflow.com/questions/6346119/asp-net-get-the-next-tuesday)  

&lt;!-- End of automatically inserted text --&gt;

Given a day of the month, how can I get the next sunday from that day?

So if I pass in Tuesday September 13th 2011, it will return Sept. 18th.




How to get the date of the next Sunday?

The await keyword in C# (.NET Async CTP) is not allowed from within a lock statement.

From [MSDN][1]:
&gt; **An
&gt; await expression cannot be used** in a synchronous function, in a query
&gt; expression, in the catch or finally block of an exception handling
&gt; statement, **in the block of a lock statement**, or in an unsafe context.

I assume this is either difficult or impossible for the compiler team to implement for some reason.

I attempted a work around with the using statement:

    class Async
    {
    	public static async Task&lt;IDisposable&gt; Lock(object obj)
    	{
    		while (!Monitor.TryEnter(obj))
    			await TaskEx.Yield();
    
    		return new ExitDisposable(obj);
    	}
    
    	private class ExitDisposable : IDisposable
    	{
    		private readonly object obj;
    		public ExitDisposable(object obj) { this.obj = obj; }
    		public void Dispose() { Monitor.Exit(this.obj); }
    	}
    }

    // example usage
    using (await Async.Lock(padlock))
    {
    	await SomethingAsync();
    }

However this does not work as expected.  The call to Monitor.Exit within ExitDisposable.Dispose seems to block indefinitely (most of the time) causing deadlocks as other threads attempt to acquire the lock.  I suspect the unreliability of my work around and the reason await statements are not allowed in lock statement are somehow related.

Does anyone know *why* await isn&#39;t allowed within the body of a lock statement?

  [1]: http://msdn.microsoft.com/en-us/library/hh191443%28v=vs.110%29.aspx

Why can&#39;t I use the &#39;await&#39; operator within the body of a lock statement?

In Go, how do you create the instance of an object from its type at run time?  I suppose you would also need to get the actual `type` of the object first too?

I am trying to do lazy instantiation to save memory.

How do you create a new instance of a struct from its type at run time in Go?

I&#39;m trying to scan an assembly for types implementing a specific interface using code similar to this:

&lt;!-- language: c# --&gt;

	public List&lt;Type&gt; FindTypesImplementing&lt;T&gt;(string assemblyPath)
	{
		var matchingTypes = new List&lt;Type&gt;();
		var asm = Assembly.LoadFrom(assemblyPath);
		foreach (var t in asm.GetTypes())
		{
			if (typeof(T).IsAssignableFrom(t))
				matchingTypes.Add(t);
		}
		return matchingTypes;
	}

My problem is, that I get a `ReflectionTypeLoadException` when calling `asm.GetTypes()` in some cases, e.g. if the assembly contains types referencing an assembly which is currently not available.

In my case, I&#39;m not interested in the types which cause the problem. The types I&#39;m searching for do not need the non-available assemblies.

The question is: is it possible to somehow skip/ignore the types which cause the exception but still process the other types contained in the assembly?

How to prevent ReflectionTypeLoadException when calling Assembly.GetTypes()

I notice that in the Java Reflection API there are two different methods for invoking constructors: the `getDeclaredConstructors`/`getConstructors` method. Although the Java docs are slightly different (`getDeclaredConstructors` seems to imply that it returns ALL constructors, rather than public ones), its not clear why the API explicitly supports these two different methods.

More importantly, I&#39;m wondering : when would one method be preferable to another if we are invoking classes dynamically ?  For example, what is the purpose of accessing a private constructor?

What is the difference between getDeclaredConstructors and getConstructors in the Class API?

I want to build a dynamic proxy object to add certain functionality to an object.

basically i want to receive an object, wrap it with an object that looks identical to the original i got, and intercept all the calls.

    class Wrapper : DynamicProxy// dynamic proxy is not a reall class, but i guess something like this exists...
    {
        public static T Wrap(T obj)
        {
            return (T) new Wrapper(obj);
        }
        
        public override object InterceptCall(MethodInfo info, object[] args)
        {
            // do stuff
        }
    
    }

------------
Just to clarify, I want to do something similar to the WCF channel factory...


---------------------

I&#39;m adding a bounty, because I need a good way to proxy classes (not interfaces) and to handle non virtual methods (as if I inherited and added a methond under the &quot;new&quot; keyword).
I&#39;m sure all this is very possible as the .Net does it.

Content Type	Original Author	Original Content on Stackoverflow
Question	netmajor	View Question on Stackoverflow
Solution 1 - C#	Francesco Baruchelli	View Answer on Stackoverflow
Solution 2 - C#	Petar Petkov	View Answer on Stackoverflow
Solution 3 - C#	eran otzap	View Answer on Stackoverflow
Solution 4 - C#	Tigran	View Answer on Stackoverflow

Get by reflection properties of class ,but not from inherited class

C# Problem Overview

C# Solutions

Solution 1 - C#

Solution 2 - C#

Solution 3 - C#

Solution 4 - C#

In JavaScript, what is the advantage of !function(){}() over (function () {})()?

Use CSS to remove the space between images

Attributions