A Design Pattern Detection Tool for Code Reuse

Total Page:16

File Type:pdf, Size:1020Kb

A Design Pattern Detection Tool for Code Reuse DP-CORE: A Design Pattern Detection Tool for Code Reuse Themistoklis Diamantopoulos, Antonis Noutsos and Andreas Symeonidis Electrical and Computer Engineering Dept., Aristotle University of Thessaloniki, Thessaloniki, Greece [email protected], [email protected], [email protected] Keywords: Design Pattern Detection, Static Code Analysis, Reverse Engineering, Code Reuse. Abstract: In order to maintain, extend or reuse software projects one has to primarily understand what a system does and how well it does it. And, while in some cases information on system functionality exists, information covering the non-functional aspects is usually unavailable. Thus, one has to infer such knowledge by extracting design patterns directly from the source code. Several tools have been developed to identify design patterns, however most of them are limited to compilable and in most cases executable code, they rely on complex representations, and do not offer the developer any control over the detected patterns. In this paper we present DP-CORE, a design pattern detection tool that defines a highly descriptive representation to detect known and define custom patterns. DP-CORE is flexible, identifying exact and approximate pattern versions even in non-compilable code. Our analysis indicates that DP-CORE provides an efficient alternative to existing design pattern detection tools. 1 INTRODUCTION ecutable. As a result, developers cannot exploit the source code of other systems without first resolving Developers need to understand existing projects in or- their dependencies and executing them correctly. Sec- der to maintain, extend, or reuse them. However, un- ondly, pattern representations in most tools are not in- derstanding usually comes down to understanding the tuitive, thus resulting in black box systems that do not source code of a project, which is inherently difficult, allow the developer any control over the detected pat- especially when the original software architecture and terns. These tools also do not offer the ability to de- design information is unavailable. And, although sev- fine custom patterns. Finally, several DPD tools are eral tools extract information from source code, in not up-to-date, supporting only obsolete versions of cases where software projects lack proper documen- programming languages. tation, the process of understanding the intent and de- In this paper, we present DP-CORE, a Design Pat- sign of the source code requires a lot of effort. tern detection tool for COde REuse, which is designed The design decisions taken during software devel- in order to overcome the aforementioned issues. DP- opment concern the non-functional aspects of the sys- CORE uses a highly descriptive and complete repre- tem, and are usually documented in the form of de- sentation for source code elements based on UML. sign patterns. Design patterns provide reusable solu- Hence, the tool supports both the detection of sev- tions in the form of templates that developers can use eral well known patterns and the definition of custom to confront commonly occurring problems (Gamma patterns by the developer. DP-CORE is also quite et al., 1998). Inferring such non-functional knowl- flexible, matching not only strictly defined versions edge from source code typically requires extracting of patterns but also similar versions of patterns using these patterns. Lately, the problem of recovering de- wildcards. Furthermore, the detection of patterns in sign patterns from source code has attracted the atten- non-executable and even non-compilable source code tion of several researchers and has led to the devel- is fully supported, while DP-CORE also uses the lat- opment of several tools to detect patterns, known as est compiler technology to support detecting patterns Design Pattern Detection (DPD) tools. in current Java projects. Most of the tools are effective for detecting cer- The rest of this paper is organized as follows. Sec- tain types of design patterns. However, they fall short tion 2 provides background knowledge and reviews in several important aspects. At first, they require the current approaches for the detection of design patterns source code to be compilable, or in most cases ex- from source code. In Section 3, we present our DPD 160 Diamantopoulos T., Noutsos A. and Symeonidis A. DP-CORE: A Design Pattern Detection Tool for Code Reuse. DOI: 10.5220/0006223301600167 In Proceedings of the Sixth International Symposium on Business Modeling and Software Design (BMSD 2016), pages 160-167 ISBN: 978-989-758-190-8 Copyright c 2016 by SCITEPRESS – Science and Technology Publications, Lda. All rights reserved DP-CORE: A Design Pattern Detection Tool for Code Reuse tool, focusing on the defined representation and the Several DPD tools in current literature employ methodology used to detect patterns, while its user in- static code analysis techniques to identify patterns. terface is presented in Section 4. Section 5 illustrates One of the first tools in this category is the DPD the usage of our tool using a case study and presents tool by Tsantalis et al. (2006), which extracts static our evaluation against the DPD tool PINOT (Shi and information about the software project including in- Olsson, 2006). Finally, Section 6 summarizes work heritance, method signatures, etc., and represents the done and provides useful insight for future research. project as a graph. Relationships among objects are represented using matrices, while the tool uses simi- larity algorithms to detect patterns. A slightly differ- 2 BACKGROUND AND RELATED ent approach is followed by Lucia et al. (2009) for the DPRE tool, which is implemented as an Eclipse plu- WORK gin. The tool constructs UML diagrams and uses vi- sual language parsing techniques to identify patterns. Software design patterns were first proposed in 1987 PINOT, designed by Shi and Olsson (2006), is an- (Beck and Cunningham, 1987), shortly after the Ob- other popular tool that combines both structural and ject Oriented Programming (OOP) paradigm began behavioral analysis. It extracts information from the gaining momentum. One of the first attempts to for- AST of the source code, and detects patterns using malize the use of design patterns was a book pub- structural and behavioral (data flow) template match- lished in 1998 by Gamma, Vlissides, Johnson, and ing. Several tools also use machine learning methods. Helm (1998), who became known as the Gang of Four Arcelli and Christina (2007) developed MARPLE, an (GoF). The GoF defined 23 patterns, which are cate- Eclipse plugin that uses neural networks to classify gorized in creational, structural, and behavioral pat- source code representations to behavioral patterns. terns. Creational patterns abstract the process of cre- The authors also extended their work, introducing ating objects, while structural patterns combine ob- JADEPT (Arcelli et al., 2008), a tool that represents jects to form larger structures and behavioral patterns patterns as combinations of rules. describe the communication between objects. Current literature in DPD methods is quite broad. FUJABA (Nickel et al., 2000) is another Eclipse According to Dong et al. (2009), the defining proper- plugin, which, among other functions, supports de- ties of a DPD tool are (a) the type of input, which can tecting design patterns. The tool defines patterns us- be source code, UML diagrams or any other repre- ing UML class diagrams and expresses their behav- sentation, (b) the intermediate representation, which ioral aspects using story-diagrams, i.e. a combina- includes all structural formats used by the DPD tool, tion of activity and interaction diagrams. Metamodel- e.g. Abstract Syntax Tree (AST), Call Dependency based approaches are also popular. Gueh´ eneuc´ and Graph (CDG), (c) the type of analysis, performed ei- Antoniol (2008) introduced DeMIMA, which extracts ther only on source code or also on the dynamic ex- classes, methods, etc. from source code to instanti- ecution trace, and (d) the type of recognition, which ate a metamodel that is used to specify objects and can be either exact or approximate. Although all of their relationships. The tool employs constraint pro- the above properties are important, the main classify- gramming techniques to identify patterns. A similar ing feature of DPD techniques is the type of analysis. approach is followed by Ptidej, designed by Kaczor Following a classification similar to that of current et al. (2006), which uses a constraints solver to detect literature (Rasool and Streitferdt, 2011; Dong et al., sets of objects that are similar to design patterns. 2007b), we distinguish among structural analysis, be- Another notable tool is D-CUBED, by Stencel and havioral analysis, and semantic analysis techniques. Wegrzynowicz (2008), which formulates design pat- Structural analysis approaches detect patterns us- terns in first order logic and inserts source code into a ing information extracted from inter-class relation- database where patterns can be identified via queries. ships (e.g. class inheritance, associations, etc.), thus Finally, DP-Miner by Dong et al. (2007a) is another they are particularly efficient for identifying cre- quite interesting tool that also uses semantics to dis- ational and structural patterns. By contrast, behav- tinguish among certain patterns that may have similar ioral analysis approaches employ dynamic program structural and behavioral aspects. The tool represents analysis, using runtime information to distinguish source code entities and relationships
Recommended publications
  • On the Interaction of Object-Oriented Design Patterns and Programming
    On the Interaction of Object-Oriented Design Patterns and Programming Languages Gerald Baumgartner∗ Konstantin L¨aufer∗∗ Vincent F. Russo∗∗∗ ∗ Department of Computer and Information Science The Ohio State University 395 Dreese Lab., 2015 Neil Ave. Columbus, OH 43210–1277, USA [email protected] ∗∗ Department of Mathematical and Computer Sciences Loyola University Chicago 6525 N. Sheridan Rd. Chicago, IL 60626, USA [email protected] ∗∗∗ Lycos, Inc. 400–2 Totten Pond Rd. Waltham, MA 02154, USA [email protected] February 29, 1996 Abstract Design patterns are distilled from many real systems to catalog common programming practice. However, some object-oriented design patterns are distorted or overly complicated because of the lack of supporting programming language constructs or mechanisms. For this paper, we have analyzed several published design patterns looking for idiomatic ways of working around constraints of the implemen- tation language. From this analysis, we lay a groundwork of general-purpose language constructs and mechanisms that, if provided by a statically typed, object-oriented language, would better support the arXiv:1905.13674v1 [cs.PL] 31 May 2019 implementation of design patterns and, transitively, benefit the construction of many real systems. In particular, our catalog of language constructs includes subtyping separate from inheritance, lexically scoped closure objects independent of classes, and multimethod dispatch. The proposed constructs and mechanisms are not radically new, but rather are adopted from a variety of languages and programming language research and combined in a new, orthogonal manner. We argue that by describing design pat- terns in terms of the proposed constructs and mechanisms, pattern descriptions become simpler and, therefore, accessible to a larger number of language communities.
    [Show full text]
  • Design Pattern Implementation in Java and Aspectj
    Design Pattern Implementation in Java and AspectJ Jan Hannemann Gregor Kiczales University of British Columbia University of British Columbia 201-2366 Main Mall 201-2366 Main Mall Vancouver B.C. V6T 1Z4 Vancouver B.C. V6T 1Z4 jan [at] cs.ubc.ca gregor [at] cs.ubc.ca ABSTRACT successor in the chain. The event handling mechanism crosscuts the Handlers. AspectJ implementations of the GoF design patterns show modularity improvements in 17 of 23 cases. These improvements When the GoF patterns were first identified, the sample are manifested in terms of better code locality, reusability, implementations were geared to the current state of the art in composability, and (un)pluggability. object-oriented languages. Other work [19, 22] has shown that implementation language affects pattern implementation, so it seems The degree of improvement in implementation modularity varies, natural to explore the effect of aspect-oriented programming with the greatest improvement coming when the pattern solution techniques [11] on the implementation of the GoF patterns. structure involves crosscutting of some form, including one object As an initial experiment we chose to develop and compare Java playing multiple roles, many objects playing one role, or an object [27] and AspectJ [25] implementations of the 23 GoF patterns. playing roles in multiple pattern instances. AspectJ is a seamless aspect-oriented extension to Java, which means that programming in AspectJ is effectively programming in Categories and Subject Descriptors Java plus aspects. D.2.11 [Software Engineering]: Software Architectures – By focusing on the GoF patterns, we are keeping the purpose, patterns, information hiding, and languages; D.3.3 intent, and applicability of 23 well-known patterns, and only allowing [Programming Languages]: Language Constructs and Features – the solution structure and solution implementation to change.
    [Show full text]
  • A Design Pattern Generation Tool
    Project Number: GFP 0801 A DESIGN PATTERN GEN ERATION TOOL A MAJOR QUALIFYING P ROJECT REPORT SUBMITTED TO THE FAC ULTY OF WORCESTER POLYTECHNIC INSTITUTE IN PARTIAL FULFILLME NT OF THE REQUIREMEN TS FOR THE DEGREE OF BACHELOR O F SCIENCE BY CAITLIN VANDYKE APRIL 23, 2009 APPROVED: PROFESSOR GARY POLLICE, ADVISOR 1 ABSTRACT This project determines the feasibility of a tool that, given code, can convert it into equivalent code (e.g. code that performs the same task) in the form of a specified design pattern. The goal is to produce an Eclipse plugin that performs this task with minimal input, such as special tags.. The final edition of this plugin will be released to the Eclipse community. ACKNOWLEGEMENTS This project was completed by Caitlin Vandyke with gratitude to Gary Pollice for his advice and assistance, as well as reference materials and troubleshooting. 2 TABLE OF CONTENTS Abstract ....................................................................................................................................................................................... 2 Acknowlegements ................................................................................................................................................................... 2 Table of Contents ..................................................................................................................................................................... 3 Table of Illustrations .............................................................................................................................................................
    [Show full text]
  • Additional Design Pattern Examples Design Patterns--Factory Method
    Additional Design Pattern Examples • Creational – Factory method – Abstract factory • Structural – Decorator – Adapter • Behavioral – Observer Design Patterns--Factory Method • Intent--Permit a class to be reuseable with arbitrary data types. Specifically, allow the class to be independent of the classes it instantiates – Define an interface for object creation. – Let subclasses decide which class to instantiate. • Motivation – Useful for development of frameworks 1 Factory Method--Continued • Consider a document-processing framework – High-level support for creating, opening, saving documents – Consistent method calls for these commands, regardless of document type (word-processor, spreadsheet, etc.) – Logic to implement these commands delegated to specific types of document objects. – May be some operations common to all document types. Factory Method--Continued Document Processing Example-General Framework: Document Application getTitle( ) * Edits 1 newDocument( ) newDocument( ) openDocument( ) openDocument( ) ... ... MyDocument Problem: How can an Application object newDocument( ) create instances of specific document classes openDocument( ) without being application-specific itself. ... 2 Factory Method--Continued Use of a document creation “factory”: Document Application getTitle( ) * Edits 1 newDocument( ) newDocument( ) openDocument( ) openDocument( ) ... ... 1 requestor * Requests-creation creator 1 <<interface>> MyDocument DocumentFactoryIF newDocument( ) createDocument(type:String):Document openDocument( ) ... DocumentFactory
    [Show full text]
  • Abstract Factory and Singleton Design Patterns to Create Decorator Pattern Objects in Web Application
    International Journal of Advanced Information Technology (IJAIT) Vol. 1, No.5, October 2011 ABSTRACT FACTORY AND SINGLETON DESIGN PATTERNS TO CREATE DECORATOR PATTERN OBJECTS IN WEB APPLICATION Vijay K Kerji Department of Computer Science and Engineering, PDA College of Engineering,Gulbarga, India [email protected] ABSTRACT Software Design Patterns are reusable designs providing common solutions to the similar kind of problems in software development. Creational patterns are that category of design patterns which aid in how objects are created, composed and represented. They abstract the creation of objects from clients thus making the application more adaptable to future requirements changes. In this work, it has been proposed and implemented the creation of objects involved in Decorator Design Pattern. (Decorator Pattern Adds Additional responsibilities to the individual objects dynamically and transparently without affecting other objects). This enhanced the reusability of the application design, made application more adaptable to future requirement changes and eased the system maintenance. Proposed DMS (Development Management System) web application is implemented using .NET framework, ASP.NET and C#. KEYWORDS Design Patterns, Abstract Factory, Singleton, Decorator, Reusability, Web Application 1. INTRODUCTION Design Patterns refer to reusable or repeatable solutions that aim to solve similar design problems during development process. Various design patterns are available to support development process. Each pattern provides the main solution for particular problem. From developer’s perspectives, design patterns produce a more maintainable design. While from user’s perspectives, the solutions provided by design patterns will enhance the usability of web applications [1] [2]. Normally, developers use their own design for a given software requirement, which may be new each time they design for a similar requirement.
    [Show full text]
  • Java Design Patterns I
    Java Design Patterns i Java Design Patterns Java Design Patterns ii Contents 1 Introduction to Design Patterns 1 1.1 Introduction......................................................1 1.2 What are Design Patterns...............................................1 1.3 Why use them.....................................................2 1.4 How to select and use one...............................................2 1.5 Categorization of patterns...............................................3 1.5.1 Creational patterns..............................................3 1.5.2 Structural patterns..............................................3 1.5.3 Behavior patterns...............................................3 2 Adapter Design Pattern 5 2.1 Adapter Pattern....................................................5 2.2 An Adapter to rescue.................................................6 2.3 Solution to the problem................................................7 2.4 Class Adapter..................................................... 11 2.5 When to use Adapter Pattern............................................. 12 2.6 Download the Source Code.............................................. 12 3 Facade Design Pattern 13 3.1 Introduction...................................................... 13 3.2 What is the Facade Pattern.............................................. 13 3.3 Solution to the problem................................................ 14 3.4 Use of the Facade Pattern............................................... 16 3.5 Download the Source Code.............................................
    [Show full text]
  • Design Patterns Past and Future
    Proceedings of Informing Science & IT Education Conference (InSITE) 2011 Design Patterns Past and Future Aleksandar Bulajic Metropolitan University, Belgrade, Serbia [email protected]; [email protected] Abstract A very important part of the software development process is service or component internal de- sign and implementation. Design Patterns (Gamma et al., 1995) provide list of the common pat- terns used in the object-oriented software design process. The primary goal of the Design Patterns is to reuse good practice in the design of new developed components or applications. Another important reason of using Design Patterns is improving common application design understand- ing and reducing communication overhead by reusing the same generic names for implemented solution. Patterns are designed to capture best practice in a specific domain. A pattern is supposed to present a problem and a solution that is supported by an example. It is always worth to listen to an expert advice, but keep in mind that common sense should decide about particular implemen- tation, even in case when are used already proven Design Patterns. Critical view and frequent and well designed testing would give an answer about design validity and a quality. Design Patterns are templates and cannot be blindly copied. Each design pattern records design idea and shall be adapted to particular implementation. Using time to research and analyze existing solutions is recommendation supported by large number of experts and authorities and fits very well in the pattern basic philosophy; reuse solution that you know has been successfully implemented in the past. Sections 2 and 3 are dedicated to the Design Patterns history and theory as well as literature sur- vey.
    [Show full text]
  • 1. Difference Between Factory Pattern and Abstract Factory Pattern S.No
    1. Difference between Factory Pattern and Abstract Factory Pattern S.No Factory Pattern Abstract Factory Pattern 1 Create object through inheritance Create object through composition 2 Produce only one product Produce families of products 3 Implements code in the abstract creator Concrete factories implements factory that make use of the concrete type that method to create product sub class produces 2.Difference between Abstract Factory Pattern And Builder Pattern S.No Builder Pattern Abstract Factory Pattern 1 In Builder Pattern, there will be one Abstract Factory Pattern will return the Director class which will instruct Builder instance directly. class to build the different parts/properties of our object and finally retrieve the object. 2 It will have reference to the created It does not keep the track of it's created object. object. 3.Difference between Builder Pattern And Composite Pattern S.No Builder Pattern Composite Pattern 1 It is used to create group of objects of It creates Parent - Child relations between predefined types. our objects. 4.Difference between MVC and MVP S.No MVP MVC 1 MVP is a bit more complex to MVC is easier to implement than MVP. implement than MVC .Also, it has additional layer for view interfaces. 2 The request is always received by the The request is received by the controller View and delegated to the presenter which in turn gets the required data and which in turn gets the data does the loads up the appropriate view processing 3 The presentation and view logic an be The controller logic can be unit tested.
    [Show full text]
  • The Dynamic Factory Pattern León Welicki Joseph W
    The Dynamic Factory Pattern León Welicki Joseph W. Yoder Rebecca Wirfs-Brock ONO (Cableuropa S.A.) The Refactory, Inc. Wirfs-Brock Associates Basauri, 7-9 7 Florida Drive 24003 S.W. Baker Road 28023, Madrid, Spain Urbana, Illinois USA 61801 Sherwood, Oregon USA +34 637 879 258 1-217-344-4847 1-503-625-9529 [email protected] [email protected] [email protected] Abstract to incorporate these new implementations without coding changes to core framework classes. The DYNAMIC FACTORY pattern describes a factory that can create product instances based on concrete type definitions stored as 3. Example external metadata. This facilitates adding new products to a A workflow system has a rule evaluation module. Each rule system without having to modify code in the factory class. implements a well-defined interface and is injected into a container that evaluates it. The rules can be simple or composite Categories and Subject Descriptors (using the COMPOSITE [7] and INTERPRETER [7] patterns) allowing D.1.5 [Programming Techniques]: Object-oriented for the creation of complex expressions by composing finer- Programming; D.2.2 [Design Tools and Techniques]: Object- grained elements. oriented design methods; D.2.11 [Software Architectures]: Patterns Creation of rules is delegated to a factory class that has a standard interface. Clients of the rules request an instance of the rule and General Terms the factory provides it. Design The workflow system vendor supplies a fixed set of rules. New rules can be added by simply providing an implementation of the Keywords rule interface. The problem comes at rule instantiation, since any Factory Objects, Adaptive Object-Models, Creational Patterns factory that contains the logic for creating rule instances may need 1.
    [Show full text]
  • Factory Pattern: Motivation • Consider the Following Scenario: – You Have
    Factory Pattern: Motivation • Consider the following scenario: { You have a superclass (P roduct) and a set of subclasses that inherit from it (P roductSubclass1, P roductSubclass2, ...) { As usual, there are a number of methods that the subclasses share in com- mon, that they inherit from the superclass { You have client code that needs to be able to create objects of the various subclasses ∗ We'll call this the orderProduct method ∗ We'll refer to the created objects as products ∗ To specify to which subclass a product should belong, orderProduct will have a parameter which specifies the type 1 Factory Pattern: Motivation (2) { For example: public class Product { //constructor ... ... step1(...) { //Methods that apply to all subclasses in common ... } ... step2(...) { ... } ... } public class ProductSubclass1 extends Product { ... } public class ProductSubclass2 extends Product { ... } public class ProductClient { ... Product orderProduct (String type) { Product product; if (type.equals("subclass1")) product = new ProductSubclass1(); else if (type.equals("subclass2")) product = new ProductSubclass2(); ... product.step1(); product.step2(); ... return product; } ... } • The problem with this approach - as usual - is limited flexibility { If we want to add new subclasses - types of products - (or remove existing ones), the client's code must be altered { The above design violates the Open/Closed Principle, among others 2 Factory Pattern: The Simple Factory Model • We want to encapsulate what varies { The part that varies is the product creation - We want to encapsulate the code that creates new products { To accomplish this, we'll create a new class that we'll call a factory { It's purpose is to create new products of a desired type { The client will have an instance variable for the factory ∗ The factory will be used from within the orderP roduct method of the client to create products 3 Factory Pattern: The Simple Factory Model (2) • Sample code: //Superclass and subclasses as before public class ProductSubclass1 extends Product { ..
    [Show full text]
  • Design Patterns Chapter 3
    A Brief Introduction to Design Patterns Jerod Weinman Department of Computer Science Grinnell College [email protected] Contents 1 Introduction 2 2 Creational Design Patterns 4 2.1 Introduction ...................................... 4 2.2 Factory ........................................ 4 2.3 Abstract Factory .................................... 5 2.4 Singleton ....................................... 8 2.5 Builder ........................................ 8 3 Structural Design Patterns 10 3.1 Introduction ...................................... 10 3.2 Adapter Pattern .................................... 10 3.3 Façade ......................................... 11 3.4 Flyweight ....................................... 12 3.5 Proxy ......................................... 13 3.6 Decorator ....................................... 14 4 Behavioral Design Patterns 20 4.1 Introduction ...................................... 20 4.2 Chain of Responsibility ................................ 20 4.3 Observer ........................................ 20 4.4 Visitor ......................................... 22 4.5 State .......................................... 25 1 Chapter 1 Introduction As you have probably experienced by now, writing correct computer programs can sometimes be quite a challenge. Writing the programs is fairly easy, it can be the “correct” part that maybe is a bit hard. One of the prime culprits is the challenge in understanding a great number of complex interactions. We all have probably experienced the crash of some application program
    [Show full text]
  • Abstract Factory Pattern Real World Example
    Abstract Factory Pattern Real World Example Sparry Reuven blackmails some spiritual and outact his swimming so fumblingly! Gasper remains unilateral: she embow her observatories allegorize too ninefold? Whining Dirk wince some menstruation and traps his Alain-Fournier so banteringly! Can You Improve This Article? Abstract factory code and features, when there are different flavors of elements of each service and every shape based on objects will implement modular gui design pattern real object step is. Do this pattern is hard before uploading a level, we are prototypical instance creation logic on desktop or dependent products are design pattern is often. Living in real world design pattern real factory world example, real world has a generic interfaces that will post helpful example, amazon web api like services. If i like this Decorator design pattern tutorial in Java then my share remains your friends and colleagues. Let's you factory method with own factory voil here read the. So basically, we release another attribute of abstraction which will identify the location and internally use again car factory implementation without even giving a single hint you the user. Sometimes, it think of patterns as recipes. It is not related to that. This is the Elven Army! In their state, we have been made up of objects of objects. What medium the intent of the merit Pool pattern? Given a real object as needed. This differs from the Observer pattern determined it allows any subscriber implementing an advance event handler to register what and vague topic notifications broadcast radio the publisher. And think is real world you have new instance property from a partial classes one place here abstract container, we have no review stack exchange is not.
    [Show full text]