The Study on the Implementation of AOP in .NET Platform

2013 ◽  
Vol 336-338 ◽  
pp. 2077-2082
Author(s):  
Zheng Yan Dong
Keyword(s):  
Design Pattern ◽  
Implementation Strategy ◽  
Object Oriented ◽  
Object Oriented Programming ◽  
Aspect Oriented Programming ◽  
The Moment

AOP(Aspect Oriented Programming) is a programming technology that makes the OOP (Object Oriented Programming) technology more complementary and perfect when being applied together with OOP technology. AOP provides ideal modularized structure for programming. At the moment, AOP has been supported and applied in two leading programming platforms: Java and .Net. Java provides perfect support to AOP, but .Net has not clearly provided the technique to support AOP. Meanwhile, Design Pattern has been widely used in programming. This study analyzes the theory of AOP technique and provides an implementation strategy for AOP based techniques on Proxy Pattern in .Net platform.

The Study and Realization of Online Submission and Peer Review System Based on AOP

2011 ◽  
Vol 295-297 ◽  
pp. 1817-1822
Author(s):  
Jing Jun Zhang ◽  
Lei Wang ◽  
Hui Li ◽  
Guang Yuan Liu
Keyword(s):  
Peer Review ◽  
Object Oriented ◽  
Object Oriented Programming ◽  
Peer Review System ◽  
Review System ◽  
Aspect Oriented Programming ◽  
Related Object ◽  
Online Submission ◽  
Authentication And Authorization ◽  
Object Models

Aspect-Oriented Programming (AOP) is a new programming technology. It compensates the weakness of Object-Oriented Programming (OOP) at applying common behavior that spans multiple non-related object models. Interceptor adopts the logos of AOP and uses a way of hot swap solving these problems. At this issue, we research the AOP technology of Java Web called Struts interceptor. We show the advantage of this new programming method through an online submission and review system which using AOP method in the authentication and authorization.

The Design and Implementation of Educational Administration System

2014 ◽  
Vol 971-973 ◽  
pp. 2667-2670
Author(s):  
Ke Tan Chen
Keyword(s):  
Educational Administration ◽  
Interface Design ◽  
Design Pattern ◽  
Object Oriented ◽  
Object Oriented Programming ◽  
Formal Representation ◽  
Administration System ◽  
Design And Implementation ◽  
System User ◽  
Advanced Applications

Teachers file management system with advanced applications. This paper describes the functional goals of the system , the system consists of eight modules, design pattern is an object-oriented programming staff to a formal representation to solve programming problems , and the system user interface design .

Problems of test-driven aspect-oriented development

2009 ◽  
Vol 38 (38) ◽  
pp. 180-186
Author(s):  
Aleksandr Sukhorukov
Keyword(s):  
Single Unit ◽  
Negative Impact ◽  
Object Oriented ◽  
Object Oriented Programming ◽  
Test Design ◽  
Aspect Oriented Programming ◽  
Test Driven Development ◽  
New Development ◽  
Unit Tests

Problems of test-driven aspect-oriented developmentTest-driven development and aspect-oriented programming are relatively new development techniques each having its own benefits. However, using aspect-oriented language like AspectJ in test-driven development leads to new types of problems that do not appear if these two approaches are applied separately. These problems arise mainly because aspect-oriented paradigm breaks encapsulation principle - behaviour of class is not implemented just in class itself like in traditional object-oriented programming but can be heavily affected by many external aspects. Traditional unit tests designed to test a single unit are not sufficient any more because behaviour being tested is distributed through several units at once, so test design becomes more complicated. In order to efficiently use these two techniques together such problems have to be identified and ways to workaround them have to be discovered. This paper focuses on those problems, describing the most notable ones. Problem descriptions are based on experience with AspectJ, but most of them are common to any aspect-oriented language with similar features. Some empirically discovered principles are provided that help softening negative impact of those problems.

scholarly journals The Role of Model-View Controller in Object Oriented Software Development

2019 ◽  
Vol 2 (2) ◽  
pp. 1-6 ◽  
Author(s):  
Ram Naresh Thakur ◽  
U.S. Pandey
Keyword(s):  
Software Development ◽  
Design Pattern ◽  
Design Patterns ◽  
Web Applications ◽  
Design Method ◽  
Object Oriented ◽  
Object Oriented Programming ◽  
Mvc Design Pattern ◽  
Model View Controller ◽  
Model View

Object Oriented Software Development (OOSD) is a design technique that is used before the development and design of a software. This design method makes the system appears as a collection of objects to communicate with other objects by passing messages. The Model-View-Controller (MVC) has been inherited from Object-Oriented Programming (OOP) with the integration of Graphical User Interface (GUI) and interactive program execution. The MVC is very useful for developing Interactive and Dynamic Web Applications and iOS. With MVC, developers can trust on design patterns that are widely accepted as solutions for recurring problems. MVC can be used to develop flexible, reusable and modular Software. Applying the MVC design pattern in object-oriented Software development a flexible, reliable, modular and scalable website can be built. So, it’s necessary for every developer to have the knowledge of software development using MVC design pattern.

scholarly journals Оцінка використання шаблонів проектування програмного забезпечення

2021 ◽  
pp. 101-109
Author(s):  
Максим Олександрович Бичок ◽  
Ольга Костянтинівна Погудіна
Keyword(s):  
Software Development ◽  
Design Pattern ◽  
Design Patterns ◽  
Unified Modeling Language ◽  
Object Oriented ◽  
Object Oriented Programming ◽  
Practical Implementation ◽  
Design Paradigm ◽  
Life Cycle Development

The subject of study in the article is software development processes using design patterns. The aim is to improve the quality of modern software development projects through the use of experience and knowledge, to build software subsystems that are focused on infrastructure and work with an external client. Objectives: to review the methodology, programming paradigms and the possibility of their application at the design and coding stages of the software development life cycle; development of the concept of using design patterns in software design as knowledge available for reuse, propose an approach to the practical implementation of design patterns to node.js projects. The models used are the Composite design pattern, the Chain of responsibility design pattern. The used methodologies are object-oriented programming, as the most common programming paradigm, a unified modeling language UML for displaying the structure of design patterns. The following results are obtained. Modern methodologies and design paradigms are considered, a classification is formed in the form of a tree structure with a division into declarative and imperative subspecies, it is concluded that within the framework of the study we will use an object-oriented methodology as the most common design paradigm. An example of building an information system of the node.js project is considered. Analyzed the main errors that arise when developing and writing code for working with an external client. The elements of the node.js project and the concepts of structuring their relationship with existing design patterns are considered. An example of a practical implementation of a node.js project and its relationship with the Composite and Chain of responsibility design patterns is considered. In this connection, the work provides the structure of these templates. Findings. The scientific novelty of the results obtained is as follows: the model of design patterns was further developed through their use in the concept of building a node.js application, which makes it possible to improve the quality of interaction between the project team and reduce its execution time.

scholarly journals A new challenge to build an application for design Generative Design Pattern

2015 ◽  
Vol 1 (2) ◽  
pp. 311
Author(s):  
Mazen Ismaeel Ghareb
Keyword(s):  
Design Pattern ◽  
Source Code ◽  
Object Oriented ◽  
Object Oriented Programming ◽  
Shared Resources ◽  
Generative Design ◽  
Object Oriented Design ◽  
Java Language ◽  
Desktop Application ◽  
Connection Line

A design pattern is used as a static reusable component of object oriented design in the many patterns catalogue. The regular design pattern does not show any collaboration of shared resource between patterns in the software design. But generative design pattern is a new design pattern that shows the relationship and shared resources between them. The generative design pattern is considered a dynamic and active design, which creating new design as a result of collaboration and resource usage between two designs. This paper will demonstrate benefit and the structure of generative pattern. It also demonstrates the creation of a desktop application for modeling generative design pattern. The Java language creates the desktop application. The application provides many features, for instance, users can place drawing objects such as class, Interface and Abstract Class object. The users also can draw different connection line between these objects, such as simple, inheritance, composition lines. This project shows the implementation details techniques of drawing objects and their connection. It also provides an open source code that many novice developers can understand and analysis for further development. The application source code gives the developers new ideas and skills in object oriented programming and graphical user interface in Java language.

scholarly journals Emulating Multiple Inheritance in Fortran 2003/2008

2015 ◽  
Vol 2015 ◽  
pp. 1-7
Author(s):  
Karla Morris
Keyword(s):  
Design Pattern ◽  
High Performance ◽  
Object Oriented ◽  
Object Oriented Programming ◽  
Multiple Inheritance ◽  
C Programming ◽  
Class Hierarchies ◽  
Fortran 90 ◽  
Performance Computing ◽  
Intrinsic Feature

Although the high-performance computing (HPC) community increasingly embraces object-oriented programming (OOP), most HPC OOP projects employ the C++ programming language. Until recently, Fortran programmers interested in mining the benefits of OOP had to emulate OOP in Fortran 90/95. The advent of widespread compiler support for Fortran 2003 now facilitates explicitly constructing object-oriented class hierarchies via inheritance and leveraging related class behaviors such as dynamic polymorphism. Although C++ allows a class to inherit from multiple parent classes, Fortran and several other OOP languages restrict or prohibit explicit multiple inheritance relationships in order to circumvent several pitfalls associated with them. Nonetheless, what appears as an intrinsic feature in one language can be modeled as a user-constructed design pattern in another language. The present paper demonstrates how to apply the facade structural design pattern to support a multiple inheritance class relationship in Fortran 2003. The design unleashes the power of the associated class relationships for modeling complicated data structures yet avoids the ambiguities that plague some multiple inheritance scenarios.

Sign in / Sign up

Export Citation Format

Share Document