Microsoft မွာ Update လုပ္ေနစဥ္ ေအာက္ က error ေပၚလာရင္..
Error: A problem on your computer is preventing updates from being downloaded
ဒါေလးကို run လိုက္ပါ။
regsvr32 wuaueng1.dll
regsvr32 wuaueng.dll
regsvr32 wucltui.dll
regsvr32 wups2.dll
regsvr32 wups.dll
regsvr32 wuweb.dll
Today’s healthcare industry moves faster than ever. Many healthcare providers face the challenge of providing the best clinical care in a complex and costly environment. Information management can play a valuable role in facing these challenges, but after years of cost increases and budget cutbacks, combined with mergers and ongoing staff shortages, healthcare providers can find that information management gets in the way of patient care. Health Level 7 (HL7) is an industry-standard application protocol for electronic data exchange of information. BizTalk Accelerator for HL7 extends the capabilities of BizTalk Server R2 for healthcare providers by delivering a comprehensive HL7 messaging solution that enables sharing of patient information within and between healthcare organizations.
Product Information
BizTalk Accelerator for HL7 delivers enhanced messaging capabilities, specific HL7 standard formats and schemas and middleware integration tools. Highlights include:
• Complete set of schemas for all HL7 v2.x message types and trigger events
• Flexible and configurable adapter for HL7's Minimal Lower Layer Protocol (MLLP)
• Ability to configure the level of message validation
• Automated and configurable support for standard HL7 message acknowledgment modes including original and enhanced acknowledgments
• Ability to process HL7 batch message protocols as well as create a batch from individual messages or split a batch into individual messages
• Configurable auditing component that allows an organization to log access to confidential patient information contained within HL7 messages
What’s New in BizTalk Accelerator for HL7 2.0
BizTalk Accelerator for HL7 2.0 includes the following:
• Support for HL7 v2.5
• Support for ordered messaging: a change was made to the MLLP adapter to leverage the support of the ordered messaging capability in BizTalk Server R2
• Support of international characters
• Enhanced socket management for MLLP: resolves connectivity issues with other rogue interface engines that have a sub-optimal TCP/IP socket implementation
• Schema generation tool to facilitate creation of customized libraries of HL7 v2 message models and generation of BizTalk Transaction Set schemas
• Fixes to the Mapper in Biztalk Server 2006 R2 to address the “segment scrambling” problem when mapping HL7 v2 messages
ျပီးခဲ့တဲ့ တစ္ရက္က အလုပ္ရွာေနတဲ့ အသိတစ္ေယာက္ က သူသြားေရာက္ခဲ့တဲ့ အင္တာဗ်ဴးမ်ား အေၾကာင္း ကိုေျပာရင္း အင္တာဗ်ဴးတစ္ခုမွ သူကို Technical Test တစ္ခုေျဖခိုင္း လိုက္ေၾကာင္းေျပာျပပါတယ္။ ဘယ္လို Test လည္းလို႕ ေမးၾကည့္တဲ့ အခါမွာ့ အလြန္စိတ္၀င္စားဖြယ္ရာ ေကာင္းမွန္းသိခဲ့ရပါတယ္။ အဲ့ဒီ site မွာ အခုေလာေလာဆယ္ ပရိုမိုရွင္း ရိွေနျပီး Free Test မ်ား ရိွေနပါတယ္။
ရမွတ္ ၂.၇၅ အထက္ရရင္ေတာ့ Certificate ကိုမွာၾကားႏိုင္ေၾကာင္းသိရပါတယ္။ အဲ့ဒီ site name ေလးကေတာ့ www.brainbench.com ျဖစ္ပါတယ္။
ပရိုဂရမ္မာ အေတာ္မ်ား သိျပီးသားျဖစ္မွာပါ။ ဒါေပမယ့္ မမွတ္မိေတာ့တို႕ ၊ သတိမရေတာ့တာတို႕ ေတြအတြက္ က်ေနာ္ျပန္ ေဖာ္ျပေပး လိုက္ပါတယ္။
အထူးသျဖင့္ အင္တာဗ်ဴးသြားမည့္ သူမ်ားအတြက္ အသံုး၀င္မယ္လို႕ ထင္ပါတယ္။
Polymorphism is often considered the most powerful feature of object-oriented programming. Greek for “many forms,” polymorphism is the ability to hide alternative implementations behind a common interface. This concept leverages inheritance and encapsulation among other OO concepts.
Polymorphism is the ability for objects of different types to respond to messages of the same type. The concept behind polymorphism is that a function or data type can be written in a generic way, so that it can handle any interactions to it regardless of the acting object’s type.
Using the abstract interfaces of objects, polymorphism can be used to create extensible and loosely-coupled programs. The benefit of this is that if new types are added, and they adhere to the common interface specified, then their impact on changing the system will be minimal.
When using inheritance based polymorphism, a class can be used as more than one type (MS Polymorphism, 2006). It can be used as its own type, any base types, or any interface type that implements its interface. In C#, every type is polymorphic. Types can be used as their own type, or as an object instance, since object is the base class of all types (MS Polymorphism, 2006).
The following scenario helps explain polymorphism. Let us assume two classes for now, class A and class B. Class A is our base class. With inheritance we know that any class that inherits from class A will inherit all of class A’s methods, fields, properties, and events. In the example below, when class B derives from A, it can choose to override the base class’s functionality.
Example 1
public class A
{
public virtual void DoSomething() {}
public virtual int SomeValue { Get { return 0; } }
}
public class B : A
{
public override void DoSomething() {}
public override int SomeValue { get { return 0; } }
}
B b = new B();
b.DoSomething(); // calls the override method in class B
Now, let’s create an instance of class A, casting our class B instance to it.
A a = (A)b; // create an instance of A casting our instance of B
a.DoSomething(); // calls the override method in class B
In Example 1, an instance of class A is created using the instance of object B. If this is confusing, then think of it as if class A were created using “A a = new B();” The object instance of class A is now using an object of the derived class B that has been cast to the base class type A. What does this mean? Well, think of it as though Class B is now being represented by a more generic object, class A.
Example 2
For another example, consider the following scenario. Human beings, whales, and dogs are related in that they are all part of the mammal class, or Mammalia. Mammals are grouped into another classification, phylum Chordata, or animals with vertebrae, or Vertebrata. I am using this example because animals of many differing species are all related in some sense, so they share similar characteristics. In the following examples, we will use less science and more OO concepts.
The Vertebrate class represents all objects that have a skull and a vertebra. This group includes mammals as well as non-mammals. These objects are able to show their skull and return a total vertebrae count. A spinal column is comprised of individual units, or vertebra.
The Mammal class represents all objects that can grow hair, have mammary glands, and without getting too scientific, have a higher rate of metabolism. For our example, all Mammal objects are able to grow hair and return their total number of mammary glands.
class Vertebrate
{
public virtual void ShowSkull() {}
public virtual int GetVertebraeCount( ) {}
}
class Mammal : Vertebrate
{
public virtual void GrowHair() {}
public virtual int GetMammaryGlandCount( ) {}
}
Canines are a type of Mammal. Before we can jump into our Beagle example, we need to see that a Beagle is a type of Canine, but it also inherits from more specific types of Canines, where each derived class offers something more specialized then its base class.
class Canine : Mammal {}
class Wolf : Canine {}
class DomesticDog : Wolf {}
class Beagle : DomesticDog {}
Human and Whale objects do not derive from Canine, but they do derive from Mammal, so they will share similar traits with all mammals.
class Human : Mammal {}
class Whale : Mammal {}
To emphasize our point of polymorphism, we have the following code. Beagles, humans, and whales are all able to grow hair.
Beagle beagle = new Beagle();
beagle.GrowHair();
Human human = new Human();
human.GrowHair();
Whale whale = new Whale();
whale.GrowHair();
In a more abstract, or generalized way, we can also say.
Mammal b = new Beagle();
b.GrowHair();
Mammal h = new Human();
h.GrowHair();
Mammal w = new Whale();
w.GrowHair();
When we create a new Mammal object, giving it the type of Beagle, we are using polymorphism. Any time we are using a base class, we could be actually using an object of the base class type, or any object that derives from the base class. The Beagle class derives from the DomesticDog, which in turn derives from the Wolf, which in turn derives from the Canine, which in turn derives from Mammal. We are four generations deep in our inheritance hierarchy, but we are still able to represent a Beagle object using the Mammal class.
At the same time, humans and whales may not seem remotely related, but they are, since they both inherit from class Mammal. We are able to represent these objects as well, using polymorphism, as seen with the following.
Mammal whale = new Whale();
whale.GrowHair();
Mammal human = new Human();
human.GrowHair();
If we wanted to go a step further, we could include sharks in our example, but we would need to use the Vertebrate class, since sharks are not derived from Mammals. We lose more specific functionality when moving up the hierarchy chain. For example, when casting a Human object to a Vertebrate object, we can no longer request human.GrowHair(); This gives us something to think about when designing systems.
Vertebrate shark = new Shark();
shark.GetVertebraeCount();
Vertebrate human = new Human();
human.GetVertebraeCount();
More on Polymorphism
As messages are sent to objects, each object must have a predefined method to respond to that message. In an inheritance hierarchy, each derived class inherits its interface from its base class. Since each derived class is a separate entity, each may require a separate response to the same message (Weisfeld, 2000).
For example, when a message is sent to GetVertebraeCount, the first thing we ask is, get vertebrae count of what? We cannot get a vertebrae count because it is too abstract, so we must provide an implementation of a concrete Vertebrate, such as Shark or Human. While Vertebrate has a GetVertebraeCount method, we need to use the more specific overridden methods found in the derived classes. We can treat Human, Shark, and Snake as Vertebrate objects, and send a GetVertebraeCount message. The end result of these messages will be different since each provides a specific implementation. Each class is able to respond in its own unique way to the same GetVertebraeCount message. This is polymorphism.
Polymorphism in Design
Polymorphism solves an important piece of the puzzle when it comes to designing a system. Good design principles tell us to program to an interface, not to an implementation. When using polymorphism, we are able to adhere to this concept, and abstract out implementations in such a way our system’s interface will not change when implementation requirements do. Once our system depends on interfaces only, we are decoupled from the implementation. The implementations can vary while our interfaces remain the same. This promotes flexibility.
References:
MS Polymorphism. (n.d.). Retrieve May 29, 2006, from http://msdn2.microsoft.com/en-us/library/ms173152(VS.80).aspx
ယခု တစ္ပတ္ အတြက္ ကြန္ပ်ဴတာ တစ္ခုအတြင္းမွာ ရိွေသာ Services မ်ားကို ေဖာ္ထုတ္ေသာ နည္းကိုေဖာ္ျပ လိုက္ရပါသည္။
// IMPORTANT: Add 'System.Management' to
// your References in your Project
using System;
using System.IO;
using System.Management;
namespace ListServices
{
///
/// Summary description for Class1.
///
class Class1
{
///
/// The main entry point for the application.
///
[STAThread]
static void Main(string[] args)
{
ManagementObjectSearcher query;
ManagementObjectCollection queryCollection = null;
System.Management.ObjectQuery oq;
string strComputerName;
string strQuery = "SELECT * FROM Win32_Service";
Console.WriteLine( "Check out http://www.mr-programmer.com for more samples, components and software\r\n" );
// Ask for a computer name
do
{
Console.Write( "Please enter server name (type 'localhost' for local machine): " );
strComputerName = Console.ReadLine();
} while( strComputerName == "" );
// Connect to the remote computer
ConnectionOptions co = new ConnectionOptions();
if (strComputerName.Trim().Length == 0)
{
Console.WriteLine("Must enter machine IP address or name.");
return;
}
//Point to machine
System.Management.ManagementScope ms = new System.Management.ManagementScope("\\\\" + strComputerName + "\\root\\cimv2", co);
//Query remote computer across the connection
oq = new System.Management.ObjectQuery(strQuery);
query = new ManagementObjectSearcher(ms,oq);
try
{
queryCollection = query.Get();
}
catch (Exception e1)
{
Console.WriteLine( "Error: " + e1 );
}
foreach ( ManagementObject mo in queryCollection )
{
//create child node for operating system
Console.WriteLine( mo["Name"].ToString() + " [" + mo["StartMode"].ToString() + "]" );
}
}
}
}
If you haven't experienced Windows Vista yet, it is a very cool operating system, but there are a lot of lessons to learn in getting up to speed in working in the new environment.
The biggest thing to get used to if you haven't been running a non-admin account on your XP machine is that there are probably a hundred things or more that you get away with that you don't even know that the reason you get away with it is that you are an admin.
In Vista, even when logged in with an administrator account, you are still not allowed to do administrator things without a privilege elevation through a mechanism called User Access Control (UAC). UAC will seem like a living hell at first because all kinds of things will stop working for you. For example, if you are only getting to some files because you are an admin, and an app such as Quicken tries to run and access those files, you will just get whatever kind of error the app vendor decided to surface for a file I/O error. However, the best way to approach it is to treat it as a learning experience to figure out how to avoid running things as admin unless you really need to (i.e. give your user account permissions to the directories you really need, don't rely on Admin privilege to give you access).
Another example is when publishing with ClickOnce. When you publish from Visual Studio to an http address, VS uses Frontpage Server Extensions (FPE) to create the virtual directory and copy the files to it. First step on Windows Vista is that you need to have IIS 6 Compatibility enabled (it is not on by default, nor is IIS installed by default like XP). Once you do that, IIS 7 knows how to look like a Frontpage Server Extension endpoint. The other thing is that you can only access the web server through FPE if you are accessing as an admin from VS.
Even when logged in as an admin, VS will not be running with admin privilege by default. As a result, when you try to publish a ClickOnce app you will get an obscure error that says that FPE is not installed on the server. Specifically:
"Failed to connect to 'http://localhost/WindowsApplication3/' with the following error: Unable to create the Web 'http://localhost/WindowsApplication3/'. The Web server does not appear to have the FrontPage server extensions installed."
The solution is quite simple: you need to run VS as an admin. To do this, you can right click on the shortcut to VS from the start menu and select Run as Administrator.
If you want to always run VS as admin, do the following:
• Go to devenv.exe in the C:\Program Files\Microsoft Visual Studio 8\Common7\IDE directory.
• Right click and go to properties.
• Select the Compatibility tab.
• Check the box at the bottom that says Run this program as an administrator (see below).
The new security protections of UAC are there for a reason. You could just turn it off and you wouldn't have problems like this in the first place. I'd encourage you not to do that. Use it as a tool to teach you how to get your work done without admin privilege to the extent possible. So in this case I prefer to only run VS as an admin when I need to by doing the right click - Run as Administrator option instead of always enabling it, but you will have to make these productivity vs security decisions for yourself.
WPF is not the end-all be-all of technologies (at least not yet ), so there are many cases where either you will still need to rely on other Windows APIs, or the other APIs are more appropiate for the task at hand. I would like to provide some guidance as to the scenarios involved for different technologies in this post.Since I am mainly a graphics geek, I am going to focus on WPF and the following APIs:
· DirectShow
· Direct3D
· GDI/GDI+
In future releases we will extend the functionality in WPF to cover additional scenarios, as well as improve the integration with other APIs, so the guidance here is subject to change. Your comments and requests are welcomed, to help us prioritize the scenarios that we should tackle first.The first concept that is going to be a common thread in dealing with many of these scenarios is HwndHost (HwndHost at MSDN and Nick's article on HwndHost). This enables you to take content that is drawn using other APIs and host it within your WPF application.There is a limitation with HwndHost in that you will not be able to apply some graphical transformations on the hwndhost content, like applying transparency or using it as a texture. Another limitation is that likely you are using unmanaged code to create the content in the hwnd, which means that this will not work in a XAML Browser Application (xbap).I am likely to follow up this posting with some background on the architectural decisions we made early on, as well as the big bets on technology trends we decided to place in late 2000/early 2001 as we started to design the WPF architecture.
WPF and DirectShowIf you want to do capture (audio or video), or have your own DirectShow filter graph, you will have to code directly to DirectShow in WPF v1. You will then take the content and host it in WPF through HwndHost.However, if all you want to do is play your own format, you can just provide a DirectShow CODEC for it, and then folks will be able to use the format through the Media element and fully integrate it as part of other WPF content, without limitations.WPF and Direct3DMy simple axiom on the 3D front is:if you already have domain knowledge in Direct3D (or OpenGL), you should stick with using Direct3D for WPF v1.Now, to provide more context on my guidance. We make 3D a lot easier to use in WPF, and by a much larger developer audience than the one that uses 3D today. We also make it usable on the Web (in a xbap), we make it print, we make it remote, and we make it easier to integrate 3D with 2D, UI controls, and Documents (including as part of XAML). But, in using WPF, you give up a bit of the flexibility and direct hardware control that you get with the lower level APIs. We also manage your data (sometimes I refer to this as "managed graphics", to go along with managed code) and in doing so there is a bit of overhead, which costs you some performance (this is very dependent on the scenario, and we are tunning this code to reduce the cost based on scenarios that early adopters are sending in, so don't wait if you run into problems).We did not optimize our architecture in this initial version for twitch games or high end scientific vizualization scenarios, so if you want to tackle something along those lines, give it a try and see if it meets your needs. Similar to the DirectShow case, once you get your content going, you use hwndHost to merge it with your WPF content.Some scenarios for this involve providing a new UI for a Direct3D based application, or hosting a 3D modeler/editor within your WPF application.WPF and GDI/GDI+For those interested in factoids - GDI and GDI+ are part of our team, and some of the WPF developers/program managers/testers were part of those efforts many years ago (and many of us were involved in VML as well).If you can't let go of raster ops, need 1-pixel wide lines, or need to load EMF/WMF files, then you will likely need to use GDI/GDI+, and then HwndHost. We are looking at how to tackle raster ops through effects, as well as provide scale invariant lines, in the future. WMF and EMF are a bit trickier, as we are trying to strike towards secure by default (even at the cost of functionality) and also because of expectations in terms of compatibility. I fully expect that some of you in the develop community will add value to the platform by developing EMF/WMF CODECs to be used within WPF applications.
ညီမငယ္တစ္ဦး ႏွင့္ သူမေကာင္ေလး ရဲ႕အကူအညီေၾကာင့္ က်ေနာ္ Windows Vista ကိုစတင္သံုးခြင့္ရရိွခဲ့ပါတယ္။ Windows Vista ရဲ႕ထူးျခားခ်က္ကေတာ့ Graphic Designs (GUI) ေတြအရမ္းေကာင္းတာေတြ႕ရျပီးေတာ့ သံုးရတာလည္း အရမ္း Smooth ျဖစ္တယ္လို႕ခံစားမိပါတယ္။ အထူးသျဖင့္ .NET framework 3.0 ရဲ႕အားသာခ်က္ အားနည္းခ်က္မ်ားကိုပါေလ့လာခြင့္ရခဲ့ပါတယ္။
.NET framework 3.0(အရင္အေခၚ WinFX) ကို Windows Vista ေပၚမွာ သံုးရန္ အထူးသင့္ေလွ်ာ္ေၾကာင္းသိရိွရျပီး၄င္း framework မ်ားတြင္ပါ၀င္သည့္ WPF (Windows Presentation Foundation, formerly code-named Avalon), WCF (Windows Communication Foundation, formerly code-named Indigo), WWF (Windows Workflow Foundation, formerly code-named Workflow) ႏွင့္ WCS (Windows Card Space, formerly code-named InfoCard) အေၾကာင္းကိုေလ့လာမိပါတယ္။
အဲ့ဒီအထဲကမွ WPF (Windows Presentation Foundation) အေၾကာင္းေလးကို စိတ္၀င္စားမယ္ဆိုရင္ က်ေနာ္ေလ့လာထားသေလာက္ ပထမဆံုးမ်ွေ၀ခ်င္ပါတယ္။
Microsoft .NET 3.0 Framework Diagram
WPF က .NET framework 3.0 ရဲ႕ Graphical Subsystem Feature တစ္ခုျဖစ္ပါတယ္။
WPF ကို Windows XP SP2 and Windows Server 2003 ေတြမွာပါ အသံုးျပဳႏိုင္တယ္လို႕ေလ့လာသိရိွရပါတယ္။ WPF သည္ Application တစ္ခုတည္ေဆာက္ဖို႕ရာမွာ Consistent programming model ကို ျဖည့္ဆည္းေပးႏိုင္ျပီး၊ UI ႏွင့္ Business Logic ၾကားမွာရွင္းရွင္းလင္းလင္းျဖစ္ေအာင္ ေဆာင္ရြက္ေပးႏိုင္ပါတယ္။
ျပီးေတာ့ WPF Application ကိုေတာ့ Desktop ႏွင့္ Web Server မ်ားမွာ deploy လုပ္လို႕ရပါတယ္။ WPF က Graphical Subsystem Feature ျဖစ္တာနဲ႕ အညီ the visual aspects ကို Develop လုပ္ရတာအလြန္ေကာင္းလွပါတယ္။ သူရဲ႕ အဓိက ရည္ရြယ္ခ်က္ကေတာ့ 2D, 3D Drawing ေတြ၊ User Interface၊ Vector Graphics, Animation, Data Binding, Audio, Video ေတြႏွင့္ Fixed လုပ္ျပီးသား အလြယ္တကူ သံုးလုိ႕ရရိွႏိုင္မယ့္ Documents ကို ထည့္သြင္း Develop လုပ္ႏိုင္ဖို႕ပါ။
WPF/E ဆိုတာကေတာ့ WPF ရဲ႕ အခြဲေလးျဖစ္ပါျပီး WPF ကိုေနရာတိုင္းမွာသံုးႏိုင္ရမယ္လို႕ဆိုလိုတာျဖစ္ပါတယ္။ သူကေတာ့ WPF ကို Mobile Version အတြက္ ျဖစ္ျပီး XAML ႏွင့္ Javascript ေပၚမွာ အေျခခံထားပါတယ္။ ျပီးေတာ့ 3D Drawing Features ေတြေတာ့ မပါပါဘူး။
WPF/E ၏ အသံုးျပဳထားတဲ့ Application တစ္ခ်ိဳ႕၏ Screen 
အခုဆက္ျပီး WPF ရဲ႕ Feature ေလးေတြအေၾကာင္းေျပာျပလိုပါတယ္။
Graphical Services
WPF သည္ 3D Model rendering ကို support လုပ္ႏိုင္ျပီး 2D applications ေတြကို အသံုးျပဳႏိုင္ပါတယ္။
Deployment
WPF သည္ ရိုးရိုး traditional standalone applications မဟုတ္ပဲ standalone XAML Browser Applications ကို Build လုပ္ႏိုင္ပါတယ္။
Interoperability
WPF သည္ Win32 မွာရိွတဲ့ Information ေတြကို ေ၀ငွသံုးစြဲႏိုင္ပါတယ္။ျပီးေတာ့ Windows Forms ႏွင့္လည္း ElementHost ႏွင့္ WindowsFormsHostေတြနဲ႕ပတ္သတ္ျပီးသံုးစြဲႏိုင္ပါတယ္။
Media Services
WPF သည္ 2D Graphics ေတြကို built-in set of brushes, pens, geometrics ေတြသံုးျပီးေတာ့ ဖန္တီးႏိုင္ပါတယ္။ 3D ေတြကိုေတာ့ Direct3D ကေပးတဲ့ Features ေတြအကုန္သံုးႏိုင္ပါတယ္။ျပီးေတာ့ သူက most of common images format ကိုလည္း support လုပ္ေပးႏိုင္ပါတယ္။ WMV, MPEG ႏွင့္ AVI ေတြ ကိုပါ support ေပးပါတယ္။
Data Binding
ထံုစံအတုိင္း Applications သံုးပါျပီဆိုမွေတာ့ အနည္းအမ်ား Informationေတြကိုသိမ္းဆည္းဖို႕လိုလာပါျပီ။ အဲ့ဒီအတြက္ Data binding ကိုပါ supportလုပ္ေပးပါတယ္။
User Interface
WPF မွာ Set of Built-in Controls ကိုစီမံေပးထားျပီး အဲ့ဒီမွာ Button, menu, List Boxေတြကိုေတြ႕ရပါတယ္။ ဒါေပမယ့္ DataGrid ကိုေတာ့မေတြ႕ရပါဘူး။ အခုေနာက္ပိုင္းေတာ့ 3rd party vendors ေတြကစျပီးေတာ့ သံုးလို႕ရျပီလို႕ေျပာပါတယ္။
WPF ၏ Basic Diagram
WPF ၏ အသံုးျပဳထားတဲ့ Application တစ္ခ်ိဳ႕၏ Screen မ်ား
WPF ကိုသံုးထားတဲ့ Applications တစ္ခ်ိဳ႕ကိုေဖာ္ျပေပးခ်င္ပါတယ္။
-Yahoo! Messenger
-New York Times Reader
က်ေနာ္ေနာက္အပိုင္းမ်ားတြင္ Techincal Terms ေတြကို အဂၤလိပ္ျမန္မာရိုက္ရတာအဆင္မေျပျဖစ္တဲ့အတြက္ အဂၤလိပ္လိုပဲေဖာ္ျပခြင့္ျပဳပါ။
Intoduction
Crystal Report comes in various flavors and the one that is required for building reports for .NET is "Crystal Report for Visual Studio .NET". It exposes a rich programming model with which we could manipulate its properties and methods during runtime. If you are developing your .NET applications using Visual Studio .NET then you won’t have to install any additional software as it is already built into Visual Studio .NET.
---- Advantages -----
Some of the major advantages of using Crystal Report for Visual Studio .NET are :
- Rapid report development
- Can extend it to complicated reports with interactive charts
- Exposes a report object model using which it can interact with other controls on the web form
- Can programmatically export the reports into widely used formats like .pdf, .doc, .xls, .html and .rtf
---- The Architecture ----
The various components that make up a simple implementation of Crystal Report as a 2-tier architecture, required for web applications are
The Client :
The client only needs a browser to access the reports which are embedded into the .aspx pages.
The Web Server hosts the :
- Crystal Report Engine (CREngine.dll)
Along with other tasks like merging the data with the report file, exporting reports into different formats, etc., it is the Report Engine that converts your Crystal Report into plain HTML that is passed on to your .aspx page.
- Crystal Report Designer (CRDesigner.dll)
The reports are created from scratch using the Crystal Report Designer, with which you could design the titles, insert data, formulas, charts, sub-reports, etc.
- The .rpt Report file
The first step to implement a report into your web application would be to create it using the Crystal Report Designer interface. You will find some ready-made .rpt samples provided with the default installation.
- The Data Source
The way your .rpt file gets the data depends on which method you choose. You can choose to make Crystal Report itself to fetch your data without writing any code for it or you can choose to manually populate a dataset and pass it on to the report file. We will look at the various possibilities a little later in this article.
- Crystal Report Viewer web form Control (CRWebFormViewer.dll)
The Crystal Report Viewer control is a web form control that can be inserted into your .aspx page. It can be thought of as a container that hosts the report on the .aspx page.
Note : In a more complex implementation, the reporting server and the web server could be on different physical servers, where the web server would make an HTTP request to the reporting server. The Crystal Reports could also be implemented as a web service.
---- Implementation Models -----
Fetching the data for the Crystal Report could be done by using any of the following methods :
- Pull Model :
where in Crystal Report handles the connection to the database using the specified driver and populates the report with the data, when requested.
- Push Model :
where it is the developer who has to write code to handle the connection and populate the dataset, and pass it on to the report. The performance can be optimized in this manner by using connection sharing and manually limiting the number of records that are passed on to the report.
---- Report Types ----
Crystal Report Designer can load reports that are included into the project as well as those that are independent of the project.
- Strongly-typed Report :
When you add a report file into the project, it becomes a ‘strongly-typed’ report. In this case, you will have the advantage of directly creating an instance of the report object, which could reduce a few lines of code, and caching it to improve performance. The related .vb file, which is hidden, can be viewed using the editor’s ‘show all files’ icon in the Solution Explorer.
- Un-Typed Report :
Those reports that are not included into the project are ‘un-typed’ reports. In this case, you will have to create an instance of the Crystal Report Engine’s 'ReportDocument' object and manually load the report into it.
---- Other things you should know ----
- Though the Crystal Report Viewer control comes with some cool in-built options like zooming, page navigation, etc., it does not have a custom print option. You will have to depend on the browser’s print feature.
- An un-registered copy of Crystal Report for Visual Studio .NET will remain active only for the first 30 uses, after which the ‘save’ option will be disabled. To avoid this, all you have to do is register the product with www.crystaldecisions.com for which you are not charged.
- The default installation will service only 5 concurrent users. To support more users, you will have to buy additional licenses from www.crystalDecisions.com
ဆုေၾကးေငြ $10,000!!!!
Windows Vista ကေအာင္ျမင္စြာႏွင့္ ေစ်းကြက္မွာ ေနရာယူလာျပီးကတည္း က
၄င္း API ကို Developers မ်ားစိတ္၀င္စားစြာအသံုးခ်လာၾကပါတယ္။
အခုခ်ိ္န္မွာေတာ့ Code Project (codeproject.com) က ၄င္း တို႕ရဲ႕ အေကာင္းဆံုး Windows Vista API Article Post မ်ားကိုျပိဳင္ပြဲ ပံုစံက်င္းပရန္စီစဥ္ေနေၾကာင္းသိရပါတယ္။ ဒီျပိဳင္ပြဲေလးဟာ အင္မတန္မွာ တန္ဖိုးရိွလွမယ့္ ရြက္ပံုးသီးပညာရွင္မ်ား ေပၚထြက္လာမွာျဖစ္ျပီး၊ မိမိရဲ႕ အတတ္္ပညာကိုလည္း တျခားသူမ်ားထံမွ်ေ၀ခံစားႏိုင္မွာျဖစ္ပါတယ္။ေနာက္ထပ္္စိတ္၀င္ စားစရာေကာင္းတာကေတာ့ ဆုေၾကးေငြပါ။
ဘာေတြလုပ္ဖို႕လုိအပ္မလဲဆိုတာကေတာ့
ခင္ဗ်ားတို႕ရဲ႕ အရမ္းေကာင္းတဲ႕ Vista Article ႏွင့္ Code sample (or App) ကို CodeProject.com ကိုပို႕ေပးလိုက္ပါ။ ဒါေပမယ့္ ခင္ဗ်ားတို႕ရဲ႕ article ကေတာ့ Vista ကိုအထူးျပဳေရးရမွာပါ။ ဆိုလိုတာကေတာ့ Vista API အေၾကာင္းကို .NET 3.0 ထက္ပိုျပီး ဦးစားေပး ေရးဖို႕ျဖစ္ပါတယ္။ပို႕ရမွာကေတာ့ Vista/.NET 3.0 area ကိုပို႕ရမွာပါ။
ဘာေတြအႏိုင္ရမွာလည္းဆိုတာကေတာ့
လစဥ္ဆု
သူတုိ႕ရဲ႕ judges ေတြက ပို႕ထားတဲ့ အထဲကမွလစဥ္စီစစ္ေရြးခ်ယ္ျပီး အဲ့ဒီအထဲကမွ ဆုေပးသြားမွာျဖစ္ပါတယ္။
ဆုရရိွမည္သူမ်ားကေတာ့ An Xbox 360, Xbox HD DVD Player, X Live Vision Camera , 12 Months XBox Live Gold Membership, Wireless Remote, 3 Xbox games စတဲ့ US$ ၁၀၀၀ ပတ္၀န္းက်င္ေလာက္ရိွမွာျဖစ္ပါတယ္။
ဆုၾကီး
လစဥ္စီစစ္ေရြးခ်ယ္ထားတဲ့အထဲကမွ ၆လျပည့္တဲ့အခါမွ အေကာင္းဆံုးကိုထပ္မံေရြးခ်ယ္မွာျဖစ္ပါတယ္။
ဆုေၾကးမ်ားကေတာ့ Sony Home Theater System, including:
• Sony 46" BRAVIA™ Flat-panel LCD Television (KDL-46V2500)
• Sony Integrated Home Theater System (DAV-DX375)
တန္ဖုိးကေတာ့ US$ 4000 ေလာက္ရိွမွာပါ။
စည္းကမ္းခ်က္မ်ား
1. The articles must focus on Vista-specific technology. This means the focus is more on the Vista API rather than on, say, .NET 3.0.
2. The articles can be in C++, C#, VB.NET or any .NET language.
3. No cheating, lying, stealing code, or biting.
4. The deadline for entries is midnight on the last day of each month.
5. The judges decision is final and no correspondance will be entered into.
6. Only those who live in jurisdictions in which this contest is legal may enter.
7. Any breach of the rules and the prize will be award to the runner up.
8. The contest will begin on December 1, 2006 and end on May 31, 2007, at 11:59:59 PM US Eastern Standard Time.
