Lớp String có 2 phương thức ToLower() và ToUpper() để chuyển 1 chuỗi sang lowercase và UPPERCASE tương ứng. Khi chuyển từ lowercase và UPPERCASE, phương thức ToTitleCase() của lớp TextInfo trở nên có ích, xem ví dụ:

using System;

// import Globalization namespace
using System.Globalization;

namespace TitleCase_CS
{
    class Program
    {
        static void Main(string[] args)
        {
            string strLow = "lower case";
            string strT = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(strLow);
            Console.WriteLine("lower case to Title Case: " + strT);

            string strCap = "UPPER CASE";
            strT = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(strCap.ToLower());
            Console.WriteLine("UPPER CASE to Title Case: " + strT);

            Console.ReadLine();
        }
    }
}

Dùng thuộc tính CurrentCulture.TextInfo để truy xuất 1 thể hiện của lớp TextInfo dựa trên culture hiện tại.

Chú ý: phương thức này không chuyển 1 từ hoàn toàn UPPERCASE, như là từ viết tắt sang TitleCase. Vì lý do đó, phải chuyển sang lowercase trước:

Kết quả:

Remoting is very important part of WCF (Windows Communication Foundation)

Here we are going to write code for retrieving remote machine process details.

1. First we need create a class i.e. .dll where we will write the functionality of the project.
2. Secondly we will create a Windows project as Server.
   
3. And finally we will create a Windows project as Client.

Step 1:

Create project New Class Library Project which will create .dll file.

Add below code.

using System;
using System.Collections.Generic;
using System.Text;
using System.Data ;
using Microsoft.Win32;
namespace RemoteClass
 {
public class Remote:MarshalByRefObject {
  public DataTable Remoteprocesses()
        {
            DataTable ProcessTable = new DataTable();
            ProcessTable.Columns.Add("processno");
            ProcessTable.Columns.Add("ProcessId");
            ProcessTable.Columns.Add("ProcessName");
            int i = 1;
            foreach (System.Diagnostics.Process winProc in
            System.Diagnostics.Process.GetProcesses())
            {
                DataRow myNewRow;
                myNewRow = ProcessTable.NewRow();
                myNewRow["processno"] = i;
                myNewRow["ProcessId"] = winProc.Id;
                myNewRow["ProcessName"] = winProc.ProcessName;
                ProcessTable.Rows.Add(myNewRow);
                i++;
            }
            return ProcessTable;
        }
    }
}

Build this project. Once your have build Project successfully the .dll file will be generated at bin/debug folder location.

Step 2:

Now create a windows application project for developing a “SERVER”. Add reference of Remote class (.dll file) in the project. Add a button and label control on the windows form. As shown in the picture

Now add below code in the .CS file . don’t forget to add Remoting related namespaces in the project and Add the names space System.Runtime.Remoting from References

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Tcp;
namespace Server
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        private void button1_Click(object sender, EventArgs e)
        {
            TcpChannel tcpChannel = new TcpChannel(8010);
            ChannelServices.RegisterChannel(tcpChannel,false);
            RemotingConfiguration.
            RegisterWellKnownServiceType(typeof(RemoteClass.Remote),
             "abc",WellKnownObjectMode.SingleCall);
            label1.Text = "Server is running";
        }
    }
}

Build this project.

Step 3:

Now create a windows application project for developing a “CLIENT”. Add reference of Remote class (.dll file) in the project.

Add a button, datagridview and label control on the windows form. As shown in the picture

Now add below code in the .CS file . don’t forget to add Remoting related namespaces in the project and Add it namesspace System.Runtime.Remoting from Reference. Just like Server project. Now on View Button Click add below Code.

using System;

using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Tcp;
//Adding the names space System.Runtime.Remoting from References 
namespace Client
{
        public partial class Form1 : Form   {
        RemoteClass.Remote RemoteObject = new RemoteClass.Remote();
        public Form1()
        {
            InitializeComponent();
        }
         private void button1_Click(object sender, EventArgs e)
        {
          RemoteObject = (RemoteClass.Remote)Activator.GetObject
         (typeof(RemoteClass.Remote), "tcp://192.168.16.51:8010/abc");
            DataTable a = RemoteObject.Remoteprocesses();
            dataGridView1.DataSource = a;
        }    }
}

Build this project.

Now let’s test the project. By pressing F5 in Server and Client project…

Here if you are having two machines namely X & Y and you want view the process details of X machine then simply you need to install the Server on the X machine and from Y machine Client you can monitor it.

i Hope u all understand a small example of remoting..if you like this example comment me..

n joy Diving in .NET World…

We offer a widespread web development service, specializing in PHP websites.
In a very short span of time Development India has had the opportunity to work with a different range of industries and clients. We optimally utilize technology as the perfect means to an end. The current focus area includes but is not limited to.NET Technologies, XML, SQL Server, PHP, MySQL & SEO.
Development India offers staff intensification services to clients enabling them to extend their staff to our offshore website development center in India. We Offer IT staffing for assets such as – Graphic Designers, ASP .Net Developers, PHP Programmers, SEO Executive, Website-developers/Website Builders in India etc.

Web Development is a combination of many skills – including design, programming, search engine optimization, content development and user experience. All elements are important, and successful websites will use all of the above elements.
Intellectual programming of a site can mechanize repetitive processes and help keep your site stable. Good programming is essential for managing large sites, where maintaining hundreds of pages manually is not an option.
Development India is a software development & web application development outsourcing company, with highlighting on high quality, well-timed delivery and lucrative offshore software & offshore web development services. We have worked with clients across multiple continents and are very aware of the challenges associated with offshore software development.

By adjusting to modern web development standards, and carefully choosing the right keywords for each page, you can increase your site’s rankings in the search engines, in particular MSN, Google, Bing & Yahoo.
Healthy written content is appealing and useful to your clients. If you sell a product or service, providing useful and original free content will keep the visitors coming back (in the hope of purchasing at some point). Unique and well crafted content is also important for SEO, as other webmasters will link to good content.
A forgotten practice among many designers and developers, designing a site for the user is critical for keeping annoyance at bay. This means having uncomplicated routing, logical content placement and a clear point to the site – what does the user want from you.
For More Information
Web Design
PHP
SEO
DOT NET
OUTSOURCING
The Author is an Executive with www.whizkraft.com

Explain the .Net Framework.
Answer – The .Net framework allows infrastructural services to all the applications developed in .net compliant language. It is an engine that provides runtime services using its component like Common Runtime Language. It consists of two main components such as Common Language Runtime and Framework Class Library.

Describe the .Net Framework Architecture.
Answer – The .Net Framework has two main components:
.Net Framework Class Library: It provides common types such as data types and object types that can be shared by all .Net compliant language.
The Common language Runtime: It provides services like code execution, type safety, security, thread management, interoperability services.

What are the components of the .Net Framework?
Answer – Class Loader, Compiler, Garbage Collection, Type checker, Debug engine, Exception Manager, Security engine, Thread manager, COM Marshallar, Class Library.

Explain the role of assembly in the .Net Framework.
Answer – .Net Framework keeps executable code or DLL in the form of assembly. .Net Framework maintains multiple versions of the application in the system through assembly. The assemblies have MSIL code and manifest that contains metadata. The metadata contains version information of the assembly.

Describe the GAC in the .Net Framework.
Answer – .Net Framework provides Global Assembly cache, a machine-wide cache. It stores shared assemblies that can be accessed by multiple languages.

Sometimes you may need to let user run your .Net application without installing .Net framework.
There are several tools called “.Net Linker” which pack a .Net application with all needed files into a single package.

Here are some of them:
• http://www.vmware.com/products/thinapp/
• http://www.xenocode.com/Products/Postbuild-for-NET/
• http://www.remotesoft.com/linker/

OK, let’s put the brand new service provider model to some good use.

Whenever a service call reports an error I want some message box telling me about it (rather than simply swallowing it, which is the default behavior). Whenever the user does something potentially devastating I want some explicit confirmation, read message box, that he knows what he’s doing. MessageBox.Show does all I need (well, it is restricted to OK and OK/Cancel, but one can live with that). Only… these system message boxes are dull, boring, and not at all a shiny example for a Silverlight application. Enter the message box service provider…

Basic implementation of a message box service

The basic implementation will get the infrastructure up and running.

The first step is defining the service contract. Show this and that and a query method. The first (and naive) version looks like this:

The default implementation of our application extension service turned service provider (AES/SP) would use the dull system message boxes to implement that. The code is actually quite straight forward:

Now, I could demand that the app.xaml has this one (or any other service implementing my interface) registered. However, I like to be correct by default, thus my accessor will fall back on this implementation if none is registered – and I can be sure that there will always be a respective service.

All that is left is a search&replace for all calls to MessageBox.Show… E.g. to show an error:

… and to get confirmation, in this case to return a book:

And, of course, it works as expected:

Replacing the Dialog

Second act. Get rid of those dull things.

Create a new “Silverlight Child Window” and style it to look like a message box. I „borrowed“ the images from the Visual Studio Image Library (on my machine under C:\Program Files\Microsoft Visual Studio 9.0\Common7\VS2008ImageLibrary\1033\VS2008ImageLibrary\Objects\png_format\WinVista\) and simply placed all possible images in the dialog. A textbox, two buttons, that’s it. Here is the styled XAML:

Some code is needed for the initialization. The message has to be set, the correct image made visible, etc.. I could probably have done this with less coding, using some tricks and elaborate databinding. But who cares, it’s straight forward and comprehensible (unlike what I probably would have come up with).

Setting the DialogResult property also closes the dialog (sik!).

Finally I need a replacement AES/SP. The main method to show the dialog looks like this:

Great? Great! … GOT YOU! (Fell into the trap myself, actually… :-/ )

Fixing the Bug

Remember that in Silverlight everything is asynchronous? Well, everything except MessageBox.Show? And ‘everything’ includes ChildWindow.Show! Meaning my confirm method will not work this way. To overcome this I decided to pass a delegate to the dialog constructor and made sure it’s called in the OK case:

And to be able to pass the delegate I changed the existing AES as well (and the interface respectively):

Of course I had to adjust the default implementation using a messagebox:

The calling code changes respectively, passing a lambda:

Done. Now my application looks nice, even if it has to show a message box:

ANFSCD…

This endeavor served actually three purposes:

• First, I wanted/needed the feature
• Second, I wanted to see/demonstrate the service provider pattern from a user’s point of view.
• And third – as you may have noticed from some screenshots – I used this implementation to check out VS2010 beta.

A quick verdict about VS 2010 beta (not really worth a separate post)…

The core system, i.e. the shell, the C# code editor, build system, etc. feels very good. No apparent bugs, quite fast, including intellisense, and close enough to VS2008 to feel familiar. Considering that big parts of this are complete rewrites, this is quite an achievement.

The visual designer for (Silverlight) XAML works nice for user controls. Designing grids, the property pane, and other tasks, is at first glance en par with Blend, but comes in a more familiar „Visual Studio flavor“; still it feels more rich and mature than VS2008.
However, there are some notable gaps. Editing of styles and templates, animations, and visual state manager are not covered. Thus my guess is that Blend will remain a necessary complement to VS, even if one has to switch less often. BTW: Contrary to what Tim wrote, I could work with Blend on VS2010 solutions (the project that cannot be loaded is only the web project), I just refrained from manipulating my project files with Blend.

Other areas I touched briefly have been less satisfying. IntelliTrace didn’t work, but I didn’t spend too much time on that. The architecture and modeling area for example has changed, but is by no means bug free (to the point of “not yet usable”). The profiler has evolved, but IMO still lacks what DevPartner offered nearly 10 years ago: a decent call graph.

Oh, one bright spot for any dev lead: code analysis (FxCop) rules are now maintained in separate files, projects reference these files by name.

Anyway, I have been using VS2010 beta since I installed it and was never compelled to switch back to VS2008. I’m going to have to reinstall my machine anytime soon, and I’m planning on going along with VS2010 beta, not installing VS2008 at all.

That’s all for now folks,
AJ.NET

As I mentioned in Part 1, the main theme of C# 4.0 is “dynamic”. Part 2 is about explaining you what’s it all about.

A static language in a dynamic world

It’s an industry trend that dynamic languages seem to be gaining popularity lately, amongst which we count fellow members as IronPython, IronRuby, F# and others.

Many, almost religious, discussions have been flooding the internet about which programming paradigm is the best, and the conclusion is, that they both have advantages and disadvantages.

It’s not so much about which is the best, but more about which can or should I use when.

Dynamic typing mostly has a very simple and succinct syntax, and has the advantage that it doesn’t need any compilation.

In a dynamic language, everything gets implicitly typed, while static languages enforce you to do the opposite: without a compiler and without explicit casting, a static language would be dead code.

On the other hand, it’s just because of C# being statically typed that most of us love it and enjoy it’s robustness and performance. Without static typing, you wouldn’t have the intelligent tools we know today, such as an Intellisense-enabled Visual Studio for instance.

Microsoft very well anticipated this trend and has built a Dynamic Language Runtime (DLR) on top of or next to the well-known Common Language Runtime (CLR), enabling the interaction of dynamic languages with the .NET 4.0 Framework.

Now, you might wonder why you would need this beast, and the truth is that, if you don’t know, you probably don’t need it J.

Anyway, any C# developer should know about its existence to know when he could actually take advantage of it. Most of us will probable even take advantage of it without knowing by using the improved COM-interop features that come with the .NET 4.0 Framework, or by doing some reflection.

Dynamically typed objects and the DLR

The Dynamic Language Runtime is the CLR-equivalent for dynamic languages. That being said, it doesn’t mean that static languages don’t use it or can’t take advantage of it.

The CLR could handle already some dynamic operations such as reflection, but it wasn’t really meant for it, and it lacked some features.

For instance, the DLR takes care about expression trees (think about LINQ statements): it receives an expression tree that represents a piece of code, and it will compile it to the most efficient MSIL-code (Microsoft Intermediate Language).

Secondly, it handles dynamic dispatch, for instance: you can have a dynamic object you know nothing about (might be a JavaScript object, Python, or just plain old .NET), and you want to invoke a method call on it. At this time, the DLR takes over and it will generate some code for you to make this method call happen in the most efficient way possible.

Next to that, the DLR does something known as “call site caching”: if a method gets called multiple times, you will have to pay only once for the overhead of the method dispatch. This overhead makes sense, because you don’t know that the method exists on that specific object, so the DLR has to look it up (luckily for you, you don’t have to). After the first call, the call site (the result of the method lookup) will get cached by the DLR to be used in any subsequent calls to that method.

On top of that, you can use both dynamic and static languages.

Because we don’t care any longer about what type of object we are working with (we do, but we don’t want to handle the coding to actually do something with it any more), the DLR has to be smart enough to handle different kinds of objects.

That’s why it is equipped with a set of binders to enable to communicate with different types of objects: it has a POCO-binder (plain old CLR object or .NET object), a JavaScript binder, a Ruby and Python binder and a COM binder.

If the object that is statically declared to be dynamic is…

• … a .NET object: the DLR uses Reflection;
• … a COM object: the DLR uses IDispatch;
• … any object implementing IDynamicObject: the DLR uses the IDynamicObject implementation of that object.

Simply put, it enables a unified programming experience for all these scenarios, and that’s where the new ‘dynamic’ keyword kicks in.

Note: The IDynamicObject and related interfaces are food for another blog post anytime soon, but it is more a .NET 4.0 feature than a C# 4.0 language specific feature. So is the DLR actually, but it is required to know about it before explaining what the language feature is all about.

The dynamic keyword was born

Some of you might recognize these pieces of code, but why reinventing the wheel if it is a very good sample, so all credit to the guy who came up with it.

Suppose you have an object that represents a calculator and allows to you get the sum of two integers. If you actually have a method that returns you a statically typed Calculator instance, your code would be very similar to this:

Suppose you could do the same by getting the calculator through reflection. Then you’re code would suddenly grow to something huge as you can find below:

Or even better, if it concerns a JavaScript object, it looks like this:

And that, for doing the same simple operation! I know a good developer is most likely to be lazy (in the good meaning of the word here), so we really don’t want to spend our days producing these kind of things.

Because we really want to take care about what our code does, and less about how it does it – especially if something as the DLR can assure us it will do it in the same way as we would do it ourselves, or even better – a new keyword has come to life to instruct the DLR to take care of it.

The code would look like the following (and could handle all of the above cases):

Pretty cool and straightforward, isn’t it?

Now the question is, after years of predication that static typing is THE way of programming, should we all do everything dynamic from now on?

Well, I’d rather agree with the following quote of Bart De Smet (Microsoft Software Development Engineer, MVP C#): calling static objects from a dynamic world is easy (e.g. PowerShell), the reverse, calling dynamic objects as if they were static, is like rowing against the current.

Compile-time dynamic, Run-time static

Don’t forget you are doing stuff dynamically here. The dynamic keyword just told the compiler that your object has to be dynamically dispatched. You don’t have Visual Studio’s Intellisense any longer, because you simply don’t know the object. Does it even have properties, or the method you would want to invoke? At compile-time, you simply don’t know.

“It is statically typed to be dynamic.”

This means, when an operand is dynamic, some things get postponed until runtime, such as:

• Member selection gets deferred to run-time
• At run-time, actual type(s) are substituted for dynamic
• The static result type of an operation will also be dynamic

Next post: C# 4.0 Series – Part 3: Optional and Named Parameters

A headline referring to the LHC particle accelerator made me laugh; the headline states: LHC has its First Collisions. Think not really; didn’t it collide with a sandwich?

http://scitech.blogs.cnn.com/2009/11/23/large-hadron-collider-has-first-collisions/

For those not informed about the LHC it is the worlds largest particle accelerator; 17 miles in circumference; tucked away in the mountains between France and Switzerland. Twice since it schedule debut it has had issues; the first of which was a power issue (uses enough energy to power a small city) and the second of them was due to bread from a sandwich which was somehow inside of it.

เกี่ยวกับ ASP.Net กันสักหน่อย

สำหรับวิธีการนี้จะอ้างอิงบน Windows 7 RTM (Build #7600) เป็นหลักนะครับ

เอาล่ะ เกริ่นนำสักนิดส์

สำหรับผู้ใช้ ASP.Net ในการพัฒนาเว็บไซต์ หนึ่งในระบบ Manage บัญชีผู้ใช้ที่ใช้กันอย่างแพร่หลาย(?) ระบบหนึ่งก็คือ ASP.Net Membership

แล้วการใช้ตัว ASP.Net Membership Provider นี่ก็ต้องมีการเข้าไปแก้ไฟล์อย่าง Machine.config เพื่อนำมาใช้กับ Web.config บ้างเป็นระยะๆ

อนึ่ง… Machine.config จะเก็บค่าปรับตั้งอย่างละเอียดของระบบ ซึ่งเป็นในลักษณะ Default Environmen ซึ่งถ้าผู้ใช้ต้องการปรับใช้ให้เหมาะกับตัวเองก็สามารถ “ก๊อปปี้” tag เหล่านั้นมาไว้ใน Web.config เพื่อ override ค่า Default ได้จ๊ะ..

แล้วทีนี้ สมมติว่าเผลอมือบอนไปแก้มันซะผิดเพี้ยน จนไม่สามารถรันได้เลย จะทำไงดี?

วิธีแรกแรก Re- Install ตัว .Net Framework 2.0 ลงไป

วิธีนี้เขาว่ากันว่าใช้งานได้ผล
…แต่ใช้กับ Vista/7 ไม่ได้ เพราะมัน Built-in มา จะ Reinstall หรือ Remove ไม่ได้

วิธีที่สอง เรียกไฟล์ .default

ในเมื่อ Machine.config พัง ก็เรียก Machine.config.default แทนขึ้นมา

วิธีนี้พอจะใช้ได้ผล ในกรณีที่กำหนดค่าผิดเพี้ยนไปก็สามารถเปิดไฟล์ Machine.config.default ขึ้นมาได้ ซึ่งไฟล์นี้ก็อยู่รวมกัน Machine.config นั้นแหละ

Default Path ของไฟล์ดังกล่าวอยู่ที่
“C:\Windows\Microsoft.NET\Framework\v2.0.50727\CONFIG”

หรือ

“%windir%\Microsoft.NET\Framework\v2.0.50727\CONFIG”

วิธีที่สาม ในกรณีที่ “จนมุม” หลังจากพยายามแก้มาน๊าน..นาน หรือ “หาไม่เจอ” หรือ “ขี้เกียจจะแก้” เรามีอีกวิธีให้คือ “ServiceModelReg.exe”

พบกับไฟล์นี้ได้ที่!
“C:\Windows\Microsoft.NET\Framework\v3.0\Windows Communication Foundation“

หรือ

“%windir%\Microsoft.NET\Framework\v3.0\Windows Communication Foundation”

ได้ตามที่่ทานต้องการ!

วิธีการใช้ก็แสนจะเบสิกคอลลี่มว๊ากๆ

คำเตือน: ใช้ภายนอกเท่านั้น
วิธีใช้

1. จงเข้าไปที่โฟลเดอร์

    

   “C:\Windows\Microsoft.NET\Framework\v3.0\” หรือ
   “%windir%\Microsoft.NET\Framework\v3.0\”

    

2. จงกด Shift แล้วคลิกขวาที่โฟลเดอร์ “Windows Communication Foundation”
3. จงเลือก “Open Command Window Here”
4. จงพิมพ์ว่า “S” แล้วกด tab เรื่อยๆไปจนถึง “ServiceModelReg.exe”
5. จงวรรค 1 ครั้ง แล้วพิมพ์ว่า -r เพื่อสั่งให้ Reinstall

ที่จริงมันสามารถทำได้หลากหลายกว่านี้มาก แต่จงอ่าน Help เอง

เมื่อได้ดังรูปแล้ว ให้กด Enter
แล้วมันจะรันบ้าบ้าอะไรไม่รู้อยู่หนึงหน้าจอ

กระบวนการนี้ใช้เวลาไม่ถึง 1 นาที!!
(ซึ่งถ้ามัวไปงมโข่งแก้ Code อาจใช้เวลาเป็นชั่วโมง เป็นวัน เดือนเดือน เป็นปี บางคนอาจทั้งชีวิต!)

เอาล่ะ…เมื่อทำได้แล้ว จงระลึกว่าไว้อย่างนึงว่า
“จงแก้ไฟล์ระบบอย่างมีสติ(มากกว่านี้)“

จบแล้วจ้า!

ปล. ถ้าบทความนี้ช่วยอะไรไม่ได้ จง Google ต่อไป สู้ๆ!!

C# 4.0 offers some exciting new features that will make life easier when working with dynamic programming scenarios or COM-interoperability.

I’ll explain these improvements, the new keyword ‘dynamic’ and also contra-variance and co-variance in these series of blog posts and I’ll try to provide you with some use cases for them to improve your code and coding experience.

The Evolution of C#

To help you understanding why these features are added to the language, and what the future of the language looks like, you must understand its history and its evolution. Behold my attempt in this first post of the series.

C# 1.0 – Codename COOL

On June 16^th 2000, almost 10 years ago, Microsoft announced the first high-level programming language to specifically target the .NET Common Language Runtime.

C# 1.0, also known under the codename COOL (C-style Object Oriented Language), was meant to provide an easy to use, object-oriented, component-based language to the .NET CLR.

It’s a language that borrowed a lot from other languages amongst which we find C++, Java, Delphi and others.

The community had to wait to get its hands on the RTM version until February 13^th 2002, but nevertheless it was an immediate hit.

There was a minor version 1.1 in April 2003, but it didn’t significantly change the theme of the 1.0 release.

C# 2.0 – Generic version of C# 1.0

When C# 2.0 rolled out, we finally had the missing features that should have been in C# 1.0, such as generic types, which were the main theme of this version and are still of huge importance in .NET development today.

New introductions were made with other features like anonymous methods, iterators and nullable types.

The latter, nullable types, was an interesting feature that was added to pave the way for C# 3.0, for which the main focus would lay on data.

C# 3.0 – Embrace your data

Most developers work with data, and this happened to be the main theme of the C# 3.0 language enhancements.

The largest language addition was LINQ (Language Integrated Query), and most others were primarily added to support this feature.

Nevertheless, these other features can and do have their value on their own, including:

• ‘var’ (implicitly typed local variable);
• Anonymous types
• Object and collection initializers
• Lambda expressions
• Extension methods

C# 4.0 – Statically typed to be dynamic

C# 4.0 will primarily focus on dynamic programming. Version 4.0 of the .NET Framework comes with a new version of the CLR, and what’s even more important, a DLR (Dynamic Language Runtime).

Now you might wonder why we would need that, but basically, this is Microsoft’s answer to the following non-exhaustive list of scenarios:

• The demand for multiple language integration, including dynamic languages, such as F#, IronRuby, IronPython,…
• Simpler reflection
• Easier COM interop
• HTML DOM access in Web scenarios

New features are:

• New keyword: dynamic (together with IDynamicObject and other cool stuff included in the .NET 4.0 Framework)
• Optional and named parameters
• Improved COM interop (combination of the 2 features above + PIA embedding feature)
• Generic contravariance and covariance

More information on what’s inside, and how to gain benefit from it, will be the topic of Part 2 in this series.

Hace unos meses Telehealth Solutions una empresa Inglesa ubicada en Watford, lanzo CardioPod, un producto en el que venimos trabajando hace ya unos cuantos meses. El mismo permite calcular el riesgo cardio-vascular de un paciente mediante la realización de una serie de test y cuestionarios.

Por ahora el producto los están usando las tres principales servicios de medicina de inglaterra, pero esperamos que en el proximo año se sumen muchas mas.

Les dejo algunos links con articulos sobre el producto:

http://www.news-medical.net/news/20090624/Telehealth-Solutions-launches-CardioPod-for-NHS-Health-Check.aspx

http://www.european-hospital.com/en/article/6058.html

http://www.ehiprimarycare.com/news/4990/cardiopod_launched_at_nhs_camden

http://scottishhealthcare.co.uk/78/edinburgh-pharmacist-cardiopod/

Web Designing has become the need of the hour. To grow your business perspectives across the world, a company needs to have a tailored and self-explanatory website which can magnetize prospect clients and fulfill the desires of the existing patrons. Therefore, it becomes mandatory to design a good and magnetic website to promote your business and give you more propositions.
These days, many particularly designed companies offer web design services. Though, the increasing usage of internet has encouraged offshore website development destinations to offer their proficiency and comprehension.
Website development in India has proved its grit with producing quality services at the restricted time frame. Indian web Development Company is focused to serve the best in this cut-throat in viable world.
For choosing the best website development company, one has to go through the online assortment of the various website development companies and appraise their work. It gives you an idea to review the company’s capabilities and a peep in its previous work. This will further help to realize the company’s potential to create some great works. Companies with ample experience will provide adequate information to its clients.
The web sites are designed on PHP, Dot Net, .Net Framework, VB.Net and Flash which are more commonly used to develop a web site. It is also important to determine the familiarity of a website development company before hiring it to work. Check the familiarity in years and adjudicate their work superiority to get the quality work done.
Sometimes, there are many economical options available in the market. But, before grabbing those offers, you should conclude your business needs and consumerist aspirations. See what you need and what is your intention. It is you who is going to pay for it. So, make sure you get the best covenant to get profitable results in the end.
Try to be clear what kind of Web Design you wish for your business and talk to the company professional to make you the same within your price range.
You’ll need to oversee and evaluate a process that is hard to comprehend, has somewhat intangible deliverables, and where the “timing of results” can’t be precisely defined. Given this scenario, how can you best work with a Search Engine Optimization (SEO) to achieve the best outcome for your website?
For More Information
Web Design
PHP
SEO
Friends and family
The Author is an Executive with www.whizkraft.com

I have been using CodeSmith for several years now. It is only second to Red-Gates SQL products, (SQL Prompt & SQL Compare). (No I am not paid by either company to make a review; just personal experience with both products).

I have written my own scripts that create strongly typed business objects, collections and DAL using CodeSmith. Some are dated and I have been trying to move them to more current technology like Ajax & jquery.

Features that I would like to see in CodeSmith

1. Better Mapping Support for map files that are not contain in the default location (My Documents\CodeSmith\Maps).
2. MasterPage like functionality for Common content structure
3. Cache dependency support know when a file has been modified in and re-compile project accordingly

 SQL Prompt a better intelli-sense tool than what is provided by MS in either VS.net or SQL Business Studio Management. It can see the database structure and allow you to join tables on FK/PK fields. It shortens the development time on queries by helping developers write queries.

SQL Prompt features I would like to see

1. Support for CLR types built-in or custom (HierarchyId, Geometry, Geography)
2. Support dependant on Server Version
3. Custom support for naming conventions on aliases; currently takes the first letter and each capitalized; (really looks ugly to see trdx) maybe a regular expression would help

Not withstanding the above feature requests; this tools are still powerful check them out for yourselves.

I recently converted over to using SVN for source control for all my projects at work.  I’ve been using it at home for over a year now.  So far…..its great!  I’m primarily using Visual Studio 2008 so I needed something that would integrate cleanly, but I also wanted something that could be used by multiple platforms since I’m looking into developing for the Mac and iPhone soon.  In addition, our budget is very limited so I needed a free solution.

Solution:

VisualSVN Server:   http://www.visualsvn.com/server/

• Easy to install SVN Server for Windows that is free if you don’t have any advanced server needs.

AnkhSVN:  http://ankhsvn.open.collab.net/

• Free Subversion SourceControl Provider for Visual Studio 2008.
• Super fast, easy to integrate with existing projects, and very clean implementation.

TortoiseSVN:  http://tortoisesvn.tigris.org/

• Integrates SVN into the shell and makes it easy to add whatever I want to source control, even if  its not in a Visual Studio project.  I used TortoiseCVS at SAS a few years ago so I figured TortoiseSVN would be of similar quality.

JIRA, Fisheye, and Greenhopper Starter:  http://www.atlassian.com/starter/

• Issue tracking, source control management and visualization, change tracking, and agile project management.
• The starter licenses are $10 each for these so the price is definitely right.  We do have a little bit of budget here and $30 is nothing.  We’re a very small team so the starter licenses are perfect for us.
• I’m just now getting this all up to speed and still in the evaluation phase, but the change tracking and issue management are top notch and installation and integration with VisualSVN server were pretty painless if you know anything about Java web applications.  I just needed to throw a little more RAM at my instances of Tomcat and its all running flawlessly now.

Eine sehr häufige Herausforderung beim Programmieren ist die Prüfung von Strings auf ihren Inhalt. Hier insbesondere die der leeren Strings. In diesem deutschen Artikel von HanseVision werden die Möglichkeiten zur Prüfung auf leere Strings dargestellt und auf die Performance-Unterschiede eingegangen. Hilfreich!

Introduction

The idea behind writing this article is to share solution to one problem that I faced recently for one my project. The problem was how we can copy an assembly (.DLL) file from Global Assembly Cache (GAC). Well, if it simply copy and paste then I am wasting my and your valuable time over here. There is no point have an article such as this. When you read the article heading, it looks pretty simple but it is not. Let’s first start with the basics.

The Basics

Assembly: According to MSDN “Assemblies are the building blocks of .NET Framework applications; they form the fundamental unit of deployment, version control, reuse, activation scoping, and security permissions. An assembly is a collection of types and resources that are built to work together and form a logical unit of functionality. An assembly provides the common language runtime with the information it needs to be aware of type implementations.“

There are two types of assembly

• Private: The assembly which is used only by a single application is called as private assembly.It does not require strong name and versioning.
• Shared: Assembly which can be used across multiple applications is called shared assembly.

Click here to find more details about assembly.

GAC (Global assembly cache):  GAC is a place where .NET assemblies are stored, specifically used to be shared by multiple applications on that computer.

GACUtil is a command line tool which allows you to place, to remove assembly from GAC.

To install an assembly called VirendraAssembly in the GAC, you can use the command.

gacutil /i VirendraAssembly.dll

To uninstall an assembly called VirendraAssembly in the GAC, you can use the command

gacutil /u VirendraAssebmly.dll

I will not go into the details of gacutil you can find from this link.

But have you ever tried to copy DLL from GAC (Global assembly cache)? Well, first time when someone asked me, I said go to GAC (c:\Windows\Assembly) folder, Select the assembly you want to copy, then right click on it and select copy option and paste it at your desired location. Well, I tried the same way but unfortunately there is no option available to copy when you make a right click on any assembly. Only available options are uninstall and properties option.

See the below screen shot.

One more thing that is noticeable is, go to DOS prompt and fire DIR command to see the listing of C:\Windows\Assembly folder and you will be surprised to see the listing. See below screen shot.

Where C:\Windows\Assembly folder looks like this.See Screenshot below:

Surprised!! Well, what you see on the DOS Prompt is the internal structure of GAC folder then why windows is not showing such structure of the GAC. Well, this is because off SHFusion.dll (Assembly cache Viewer). On the Dos Prompt fire Dir /AH command. It shows desktop.ini. SHFusion.dll uses this desktop.ini file to show abstract view of GAC.

Various Techniques to show internal structure of GAC

There are 4 ways to show the same structure for GAC in windows as we will in DOS.

Rename the Desktop.ini file

As I mentioned previously, SHFusion.dll make use of desktop.ini to determine how to display the content of the GAC folder. From DOS prompt, fire these commands to rename the desktop.ini file.

attrib desktop.ini -h -r -s
rename desktop.ini desktop.ini.bak

Now, go to C:\Windows\Assembly folder to see its content. Screen will look something like below screenshot

You can also see the particular folder content. Select GAC and you will see something like this.

If you want to see both the view together run this series of commands on DOS Prompt.

Assuming you are on c:\ drive.

cd Windows\Assembly
attrib -r -h -s desktop.ini
mkdir OriginalView
move desktop.ini OriginalView
attrib +s OriginalView
attrib +r +h +s OriginalView/desktop.ini

Now, go to assembly folder. You will internal structure of GAC and plus one more folder named OriginalView. When you go in this folder, you will  see original view of GAC.

By Modifying the Registry

The following steps will modify the registry. If you make any incorrect entry in registry, that can cause some serious problems. Sometimes you may need to install operating system again. Use registry editor at your own risk. I prefer, before you follow these steps, take a backup of registry.

We need to add a key in registry that will disable the abstract view of the GAC.

To open registry editor, Go to Run and type regedit. Locate following registry, in the registry editor.
HKEY_Local_Machine\Software\Microsoft\Fusion\

Right click on Fusion Folder and select New ->DWord Value.

Add a new Dword named “DisableCacheViewer” and set its value 1.

Now go to C:\Windows\Assembly folder and you will see folders in GAC.

By Uninstalling SHFusion.dll

Go to Visual Studio Command Prompt and fire this command to uninstall the SHFusion.dll

regsvr32 -u C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\shfusion.dll

Following message will appear.

Now go to C:\Windows\Assembly folder and you will see folders in GAC.

To get back to the previous state of view register the SHfusion.dll using the following command, fire this command on Visual Studio Command prompt.

regsvr32 C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\shfusion.dll

And you will see following message on the screen.

Now go to Assembly folder again and it will show the abstract view of GAC.

Using SUBST Command

Go to Windows DOS Prompt and type following command and press enter.

SUBST L: “C:\Windows\Assembly”

This command will create a virtual drive “L” and this drive will have the internal view of GAC, where C:\Windows\Assembly will have the abstract view of GAC. Kindly ensure that the drive name that you type in SUBST command, it must not exist in your system. Go to My Computer and you will see the Drive named “L:”.

Now to delete this drive, run this command on command prompt.

SUBST L: /D

This will delete the L: drive.

By all above these four techniques, you can see the internal structure of GAC. Via Internal structure you can copy the DLL and paste it at desired location.

Now, let’s see what every folder contains in GAC. Mainly there are 5 Folders.

1. GAC : This folder contains non-native images of DLL used in .NET Framework 1.x.
2. GAC_32 : A 32-bit system will only have the GAC_32 directory.  A 64-bit system will have both the directory GAC_32 and GAC_64. These directories contain assemblies that are specific to 32-64 bit mode.
3. GAC_MSIL: The GAC_MSIL cache contains assemblies that can be run in either 32-bit or 64-bit mode. They don’t have any dependency.
4. NativeImage Framework Version :  Native image generated for Framework version. If you have .NET Framework 1.0 and 2.0 both, then there will be two directories.
5. Temporary and Tmp : Temporary Directories.

The folder GAC, GAC_32, GAC_64 and GAC_MSIL contains non-native images of the DLLs. They all contain the MSIL that will be complied into native images and placed in NativeImage_Framework Version folder.

Reference

http://www.codeproject.com/KB/dotnet/demystifygac.aspx
http://blogs.msdn.com/junfeng/archive/2004/09/12/228635.aspx

Conclusion

During this article, I have showed you various techniques to show internal structure of GAC and one can easily copy the DLL from the GAC folder and can paste it at desired location. I hope that readers will learn something new.

Kindly post your comments regarding feedback for this article.

Thanks,
Virendra Dugar

I have a strange fascination with hybrids.  Combining old and new technologies in bizarre and interesting ways.   Why must developers make “the choice” between a web or native technology? It would be great to build applications that would increase or decrease in features depending on the platform they were run on.

Do you have a Winforms application that you’d like to host in a web browser?  There’s an interesting technique you can use to do this enabled by .net Framework 3.5.

The .net framework provides the ability to create WPF web applications (commonly called XBAP).  WPF has the ability, in turn, to host Winforms. 

Security

It appears that in order to do this effectively, it’s necessary to deploy your XBAP application as a “Full Trust” application.

The code

To use this, create an XBAP project, then a page a “WinformHost” control on it.   The XAML could look like this:

<Page x:Class="Page1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Page1">
    <DockPanel LastChildFill="True">
        <Button Name="Button1"  DockPanel.Dock="Bottom"  >This is a WPF Button</Button>
        <WindowsFormsHost Name="WinformHost"   />
    </DockPanel>
</Page>

Then, create some code to instantiate your winform and show it on the Winform host:

Class Page1

Here’s the subroutine:

Public NotInheritable Class WinformToUserControl

Interesting bits and pieces

We found that in order for the items inside the control to scale properly, the AutoScaleMode property on the Winform must be set to Dpi instead of the default, which is Font.  I have a feeling this is because Dpi is the mode preferred for WPF, but I am uncertain.

In the sample WinformToUserControl class I found it better to contain the Winform inside a panel rather than exposing the Winform directly.  It seemed to make it more stable.  Feel free to experiment with taking it off.

Gotchas

As of time of writing, Firefox on my Windows 7 64 bit machine steadfastly refuses to run xbap.  It appears the “Windows Presentation Foundation” addin has not been automatically installed.  I have no idea how to install it.  There’ appears to be no information about how to do so.  So if you have it, good for you.  If you don’t….try re-installing the .net framework 3.51 (which didn’t work for me…)

I do know there was some controversy about this addin being temporarily blacklisted by Mozilla due to security concerns last month, but that’s all over now isn’t it?  

Download

You can download a sample project here.

Links

• I didn’t use anything from this project, but you might find it interesting MdiWindowManager
• StackOverflow post on Embedding winforms in usercontrols

Ever wanted to list the properties of controls in a ComboBox to change the appearance of your app at run-time? Rather than typing out a long list of names to add to the ComboBox, use Enum to add the list of choices…

In this example we will change 2 properties of a TabControl – the TabAlignment and BorderStyle – using a selection from a ComboBox.

To begin with, create an app with 2 ComboBoxes and 1 TabControl.

The first bit of code to write is to populate the ComboBoxes with data. We’ll begin by focusing on the ComboBox for the BorderStyle choices. One way to add the possible choices is use ComboBox.Items.AddRange method, and type them all out.  So in your Form1_Load event, type this:

ComboBox1.Items.AddRange(New String() {"None", "FixedSingle", "Fixed3D"})

Of course, before you do that you would have to look in the TabPages collection in the TabControl properties list. Then look at all of the choices for BorderStyle… For BorderStyle, there are only 3 choices, so not too big a deal. However, what if the were a dozen (or more) choices? Or, take for example, the colors available for something like BackColor? There are somewhere around 130 different KnownColors in VB.NET. That would be a lot of typing and quite a few lines of code.

We can shorten that considerably by using an enumeration to load the items into the ComboBox. So let’s erase the line of code above and type this instead:

ComboBox1.Items.AddRange([Enum].GetNames(GetType(BorderStyle)))

Now do the same thing for ComboBox2, except get the enumeration for TabAlignment.

Then to change these properties at run-time, add a couple of lines of code in the SelectedIndexChanged event for each ComboBox.
Private Sub ComboBox1_SelectedIndexChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles ComboBox1.SelectedIndexChanged
Dim brdrStyle As BorderStyle = CType(ComboBox1.SelectedIndex, BorderStyle)
For Each tp As TabPage In TabControl1.TabPages
tp.BorderStyle = brdrStyle
Next
End Sub
Private Sub ComboBox2_SelectedIndexChanged(ByVal sender As Object, ByVal e As System.EventArgs) Handles ComboBox2.SelectedIndexChanged
Dim tabAlign As TabAlignment = CType(ComboBox2.SelectedIndex, TabAlignment)
TabControl1.Alignment = tabAlign
End Sub

Now hit F5 to run your code to see how the appearance of the TabControl changes when you change the selection in each ComboBox.

Note: This is part of a series, you can find the related posts here…

The last post used the new Application Extension Services (AES for short) to include security into the application. This time I’m going to take AES one step further, laying out yet another piece of basic infrastructure.

As a quick recap: An AES is a simple class, implementing a simple interface (IApplicationService) and optionally another one (IApplicationLifetimeAware). It is then registered by the developer via the app.xaml. SL3 instantiates the AES at runtime and calls the respective callback methods on said interfaces, including StartService, StopService, and others. The recommended way to use these services is to maintain a static property and reference the class accordingly.

Basically AES solve one problem: How do I extend the global application class, without actually replacing it, i.e. without providing a derived class?

The problem here is that many libraries need some kind of global anchor and in the past, tool developers often chose to provide this by subclassing the next available central artifact (e.g. the page class or the application). And the next tool developer doing the same rendered those two libraries mutually exclusive, just by employing an adverse implementation strategy.

However, SL3 solves only the providing part of the equation, the part related to the application class and the instantiation of the AES. But look again at the consumer code:

Following the recommendations, I get singleton access to some object. Worse, the calling code is directly and tightly coupled to the AES class. But frankly, do I need SL3 to implement a singleton? Certainly not. Then why use AES in the first place?

What I’d love is to have the consumer code depend on some service (read interface), not on the actual implementation. And the ability to swap those services in and out, without affecting the caller. Matter of fact, the calling code doesn’t and shouldn’t care whether I use a SecurityServiceThatGetsItsInformationFromTheServer or a SecurityServiceThatGetsItsInformationFromWindowsAzure (or google account, open id, whatever).

If I could get that, AES would become a very valuable feature… . 

Introducing Service Providers

OK, what the calling code needs is some service in terms of a contract, say ISecurityService, that it can ask for. And the same is true for any crosscutting concern, such as error reporting, tracing, caching, you name it. And actually .NET has already addressed this need with the service provider pattern. This pattern has been used for example in WF (e.g. to introduce workflow instance persistence), and quite extensively in the Visual Studio design time infrastructure.

OK, I can hear you crying out DI. And the chorus chanting Unity or Ninject (to name just two that support SL). But think again. Would you (or rather a library developer) mandate a specific DI container without reason? And you can always wire your pet container into this pattern by providing a IFactory service using whatever container you like. After all, the pattern handles access to services, not instantiation of them. (Which is what AES does, but again, Microsoft chose not to provide a fully fledged DI container…)

What do I need to make this approach tick? I need a GetService method that iterates all AES – they are available via Application.ApplicationLifetimeObjects. And I need something to attach this method to. Using an extension method I can actually attach it to the application class:

The method iterates all AES, checks whether one implements the requested (interface) type. It also checks whether any AES itself follows the pattern and implements IServiceProvider, and respectively forwards the request if it does. (This allows me to build up a chain of providers.)

That’s it. Long talk, short implementation, all set

Reimplementing the SecurityService

Now I need the rework the SecurityService and the calling code to comply with the pattern. The service interface is simple enough:

And my revised security service looks like this:

The base class ApplicationServiceBase implements the two interfaces with respective empty virtual methods, thus I only had to overwrite StartService. Aside from some reformatting the most notable difference with the previous implementation is the absence of the static Current property to access the service instance at runtime. I also renamed the class to reflect what it does. Since the calling code won’t refer to that name any more, this is now feasible.

Accessing the service at runtime is done – drum roll please – using the service provider pattern. This (admittedly not exactly nice) code can be hidden in a simple static property, adding a little convenience. I did this with a class that provides a static property, but also allows calling an extension method on the Application class:

BTW: Wouldn’t it be nice to have extension properties that I could attach to the application class…?

And the calling code, i.e. the access to the user object changes to:

Now the calling code is completely decoupled from the actual implementation of the security service, meaning I could replace it without affecting the calling code.

A look ahead: Building on the pattern

There are several use cases for this pattern that I will employ (they may or may not be addressed in later posts, but at least this list should give you some ideas):

• Last chance exception handling: A service will react to the unhandled exception event and gather context information. It will then use another service to report the error.
• Message boxes: I will need message boxes for errors, information, and confirmation. The system MessageBox is however somewhat dull. A service will cover that and a later implementation will replace the boring system dialogs with nice and shiny replacements.
• Logging and tracing: At some point I will have to tackle these demands.
• …

I’m sure you can think of other examples, like navigation with parameter passing, global state, caching, …. Anyway, I think this is motivation enough to roll out some additional infrastructure.

As a side note: Actually I had a completely homegrown implementation of this pattern for SL2. When SL3 came out and offered AES I quickly jumped on the bandwagon and threw away most of that code. If only Microsoft had not stopped one step short of my needs… . I’d rather have the platform support that out-of-the-box. And given the simplicity of the remaining implementation this shouldn’t have been too much of an issue.

That’s all for now folks,
AJ.NET

Today Microsoft released the Bing Silverlight control RTW. Speak and you shall receive; I am utterly surprised by its release.

http://msdn.microsoft.com/en-us/library/ee681900.aspx