setter - Page 22 - Developer IT

How to retrieve ImageUri of an ImageView?

- by user336675

I'm looking forward the method for accessing the current image's Uri from an ImageView, to save it to my database, but i've only found the setter. Where's the getter??

can any body help me for the syntax of setters and getters??m

- by Azka

i have set mName, mContact and memail as my variables.. and i want to use them in setter and getters.. can any body help me doing so? only want to know the syntax.. regards..

Why we need to set the variable private / public?

- by Tattat

Why don't make all variable private? All the variables must give a getter, setter to modify/read. Why leave the "public" keyword here? Except for convenient, any another reason for that?

Creating a dynamic proxy generator with c# – Part 2 – Interceptor Design

Creating a dynamic proxy generator – Part 1 – Creating the Assembly builder, Module builder and caching mechanism For the latest code go to http://rapidioc.codeplex.com/ Before getting too involved in generating the proxy, I thought it would be worth while going through the intended design, this is important as the next step is to start creating the constructors for the proxy. Each proxy derives from a specified type The proxy has a corresponding constructor for each of the base type constructors The proxy has overrides for all methods and properties marked as Virtual on the base type For each overridden method, there is also a private method whose sole job is to call the base method. For each overridden method, a delegate is created whose sole job is to call the private method that calls the base method. The following class diagram shows the main classes and interfaces involved in the interception process. I’ll go through each of them to explain their place in the overall proxy. IProxy Interface The proxy implements the IProxy interface for the sole purpose of adding custom interceptors. This allows the created proxy interface to be cast as an IProxy and then simply add Interceptors by calling it’s AddInterceptor method. This is done internally within the proxy building process so the consumer of the API doesn’t need knowledge of this. IInterceptor Interface The IInterceptor interface has one method: Handle. The handle method accepts a IMethodInvocation parameter which contains methods and data for handling method interception. Multiple classes that implement this interface can be added to the proxy. Each method override in the proxy calls the handle method rather than simply calling the base method. How the proxy fully works will be explained in the next section MethodInvocation. IMethodInvocation Interface & MethodInvocation class The MethodInvocation will contain one main method and multiple helper properties. Continue Method The method Continue() has two functions hidden away from the consumer. When Continue is called, if there are multiple Interceptors, the next Interceptors Handle method is called. If all Interceptors Handle methods have been called, the Continue method then calls the base class method. Properties The MethodInvocation will contain multiple helper properties including at least the following: Method Name (Read Only) Method Arguments (Read and Write) Method Argument Types (Read Only) Method Result (Read and Write) – this property remains null if the method return type is void Target Object (Read Only) Return Type (Read Only) DefaultInterceptor class The DefaultInterceptor class is a simple class that implements the IInterceptor interface. Here is the code: DefaultInterceptor namespace Rapid.DynamicProxy.Interception { /// <summary> /// Default interceptor for the proxy. /// </summary> /// <typeparam name="TBase">The base type.</typeparam> public class DefaultInterceptor<TBase> : IInterceptor<TBase> where TBase : class { /// <summary> /// Handles the specified method invocation. /// </summary> /// <param name="methodInvocation">The method invocation.</param> public void Handle(IMethodInvocation<TBase> methodInvocation) { methodInvocation.Continue(); } } } This is automatically created in the proxy and is the first interceptor that each method override calls. It’s sole function is to ensure that if no interceptors have been added, the base method is still called. Custom Interceptor Example A consumer of the Rapid.DynamicProxy API could create an interceptor for logging when the FirstName property of the User class is set. Just for illustration, I have also wrapped a transaction around the methodInvocation.Coninue() method. This means that any overriden methods within the user class will run within a transaction scope. MyInterceptor public class MyInterceptor : IInterceptor<User<int, IRepository>> { public void Handle(IMethodInvocation<User<int, IRepository>> methodInvocation) { if (methodInvocation.Name == "set_FirstName") { Logger.Log("First name seting to: " + methodInvocation.Arguments[0]); } using (TransactionScope scope = new TransactionScope()) { methodInvocation.Continue(); } if (methodInvocation.Name == "set_FirstName") { Logger.Log("First name has been set to: " + methodInvocation.Arguments[0]); } } } Overridden Method Example To show a taster of what the overridden methods on the proxy would look like, the setter method for the property FirstName used in the above example would look something similar to the following (this is not real code but will look similar): set_FirstName public override void set_FirstName(string value) { set_FirstNameBaseMethodDelegate callBase = new set_FirstNameBaseMethodDelegate(this.set_FirstNameProxyGetBaseMethod); object[] arguments = new object[] { value }; IMethodInvocation<User<IRepository>> methodInvocation = new MethodInvocation<User<IRepository>>(this, callBase, "set_FirstName", arguments, interceptors); this.Interceptors[0].Handle(methodInvocation); } As you can see, a delegate instance is created which calls to a private method on the class, the private method calls the base method and would look like the following: calls base setter private void set_FirstNameProxyGetBaseMethod(string value) { base.set_FirstName(value); } The delegate is invoked when methodInvocation.Continue() is called within an interceptor. The set_FirstName parameters are loaded into an object array. The current instance, delegate, method name and method arguments are passed into the methodInvocation constructor (there will be more data not illustrated here passed in when created including method info, return types, argument types etc.) The DefaultInterceptor’s Handle method is called with the methodInvocation instance as it’s parameter. Obviously methods can have return values, ref and out parameters etc. in these cases the generated method override body will be slightly different from above. I’ll go into more detail on these aspects as we build them. Conclusion I hope this has been useful, I can’t guarantee that the proxy will look exactly like the above, but at the moment, this is pretty much what I intend to do. Always worth downloading the code at http://rapidioc.codeplex.com/ to see the latest. There will also be some tests that you can debug through to help see what’s going on. Cheers, Sean.

Search Results

Search found 902 results on 37 pages for 'setter'.

Page 22/37 | < Previous Page | 18 19 20 21 22 23 24 25 26 27 28 29 | Next Page >

- by user336675

- by Azka

- by Tattat

- by SeanMcAlinden

- by Geordie

- by nmarun

- by gandil

- by Mike B

- by Robert Rossney

- by Dylan Lin

- by user8472

- by Brian Genisio's House Of Bilz

- by Stephen.Walther

- by kerry

- by sytycs

- by Lewis Bassett

- by Winston Ewert

- by Schemer

- by Ondrej Brejla

- by Ikuzen

- by MrLane

- by Peter Penzov

- by Theomax

- by Laurent Bugnion

- by Prog

< Previous Page | 18 19 20 21 22 23 24 25 26 27 28 29 | Next Page >